src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
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); } | @Test public void testSetStatement() throws Exception { } |
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(); } | @Test public void testIsSLF4jImplementationAvailable() throws Exception { Assert.assertEquals(false, MjdbcLogger.isSLF4jImplementationAvailable()); } |
QueryRunner extends AbstractQueryRunner { public int[] batch(String sql, Object[][] params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(params, nullException()); return this.batch(this.getStatementHandler(), sql, getQueryParams(params)); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); QueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); int[] batch(String sql, Object[][] params); int[] batch(InputHandler[] inputHandlers); T query(String sql, OutputHandler<T> outputHandler, Object... params); T query(InputHandler inputHandler, OutputHandler<T> outputHandler); T query(String sql, OutputHandler<T> outputHandler); int update(String sql); int update(String sql, Object param); int update(String sql, Object... params); int update(InputHandler inputHandler); T update(InputHandler inputHandler, OutputHandler<T> outputHandler); T update(String sql, OutputHandler<T> outputHandler, Object... params); T execute(AbstractXmlInputOutputHandler<T> inputHandler); QueryParameters call(AbstractQueryInputHandler inputHandler); T call(AbstractNamedInputHandler<T> inputHandler, String catalog, String schema, boolean useCache); T call(AbstractNamedInputHandler<T> inputHandler); CallResults call(InputHandler<T> inputHandler, OutputHandler<S> outputHandler, String catalog, String schema, boolean useCache); CallResults call(InputHandler<T> inputHandler, OutputHandler<S> outputHandler); } | @Test public void testBatch1NoValue() throws Exception { queryRunner.batch("", new Object[0][0]); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(any(String.class)); verify(preparedStatement, times(1)).executeBatch(); verify(statementHandler, never()).setStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, never()).readStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, never()).wrap(any(Statement.class)); verify(statementHandler, times(1)).beforeClose(); verify(statementHandler, times(1)).afterClose(); verify(metadataHandler, never()).getProcedureParameters(any(Connection.class), any(String.class), any(String.class), any(String.class), any(boolean.class)); }
@Test public void testBatch1Value() throws Exception { queryRunner.batch("bla", new Object[][]{{"bla"}}); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(any(String.class)); verify(preparedStatement, times(1)).executeBatch(); verify(statementHandler, times(1)).setStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, never()).readStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, never()).wrap(any(Statement.class)); verify(statementHandler, times(1)).beforeClose(); verify(statementHandler, times(1)).afterClose(); verify(metadataHandler, never()).getProcedureParameters(any(Connection.class), any(String.class), any(String.class), any(String.class), any(boolean.class)); }
@Test(expected = java.sql.SQLException.class) public void testBatch1SqlNull() throws Exception { queryRunner.batch(null, new Object[][]{{"bla"}}); }
@Test(expected = java.sql.SQLException.class) public void testBatch1ParamNull() throws Exception { queryRunner.batch("", null); }
@Test(expected = java.sql.SQLException.class) public void testBatch2NoValue() throws Exception { queryRunner.batch(new InputHandler[]{}); }
@Test public void testBatch2Value() throws Exception { queryRunner.batch(new InputHandler[]{new QueryInputHandler("bla", new QueryParameters())}); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(any(String.class)); verify(preparedStatement, times(1)).executeBatch(); verify(statementHandler, times(1)).setStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, never()).readStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, never()).wrap(any(Statement.class)); verify(statementHandler, times(1)).beforeClose(); verify(statementHandler, times(1)).afterClose(); verify(metadataHandler, never()).getProcedureParameters(any(Connection.class), any(String.class), any(String.class), any(String.class), any(boolean.class)); }
@Test(expected = java.lang.IllegalArgumentException.class) public void testBatch2SqlNull() throws Exception { queryRunner.batch(new InputHandler[]{new QueryInputHandler(null, new QueryParameters())}); }
@Test(expected = java.lang.IllegalArgumentException.class) public void testBatch2ParamNull() throws Exception { queryRunner.batch(new InputHandler[]{new QueryInputHandler("SELECT :value", null)}); } |
QueryRunner extends AbstractQueryRunner { public <T> T query(String sql, OutputHandler<T> outputHandler, Object... params) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); AssertUtils.assertNotNull(outputHandler, nullException()); return this.<T>query(this.getStatementHandler(), sql, outputHandler, new QueryParameters(params)); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); QueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); int[] batch(String sql, Object[][] params); int[] batch(InputHandler[] inputHandlers); T query(String sql, OutputHandler<T> outputHandler, Object... params); T query(InputHandler inputHandler, OutputHandler<T> outputHandler); T query(String sql, OutputHandler<T> outputHandler); int update(String sql); int update(String sql, Object param); int update(String sql, Object... params); int update(InputHandler inputHandler); T update(InputHandler inputHandler, OutputHandler<T> outputHandler); T update(String sql, OutputHandler<T> outputHandler, Object... params); T execute(AbstractXmlInputOutputHandler<T> inputHandler); QueryParameters call(AbstractQueryInputHandler inputHandler); T call(AbstractNamedInputHandler<T> inputHandler, String catalog, String schema, boolean useCache); T call(AbstractNamedInputHandler<T> inputHandler); CallResults call(InputHandler<T> inputHandler, OutputHandler<S> outputHandler, String catalog, String schema, boolean useCache); CallResults call(InputHandler<T> inputHandler, OutputHandler<S> outputHandler); } | @Test(expected = java.sql.SQLException.class) public void testQuery1SqlNull() throws Exception { queryRunner.query((String) null, new MapOutputHandler()); }
@Test(expected = java.sql.SQLException.class) public void testQuery1ParamNull() throws Exception { queryRunner.query("", null); }
@Test(expected = IllegalArgumentException.class) public void testQuery2SqlNull() throws Exception { queryRunner.query(new QueryInputHandler(null, new QueryParameters().set("value", "bla")), new MapOutputHandler()); }
@Test(expected = java.sql.SQLException.class) public void testQuery2ParamNull() throws Exception { queryRunner.query(new QueryInputHandler("SELECT :value", new QueryParameters().set("value", "bla")), null); }
@Test public void testQueryLazy() throws SQLException { ((QueryRunner) queryRunner).setStatementHandler(new LazyStatementHandler(new Overrider())); when(transactionHandler.getManualMode()).thenReturn(true); queryRunner.query("some sql", new MapLazyOutputHandler()); }
@Test(expected = MjdbcRuntimeException.class) public void testQueryLazyException() throws SQLException { ((QueryRunner) queryRunner).setStatementHandler(new LazyStatementHandler(new Overrider())); queryRunner.query("some sql", new MapLazyOutputHandler()); }
@Test(expected = java.sql.SQLException.class) public void testQuery3SqlNull() throws Exception { queryRunner.query((String) null, new MapOutputHandler()); }
@Test(expected = java.sql.SQLException.class) public void testQuery3ParamNull() throws Exception { queryRunner.query("some sql", null); } |
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); } | @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(); } |
QueryRunner extends AbstractQueryRunner { public int update(String sql) throws SQLException { AssertUtils.assertNotNull(sql, nullException()); Integer rows = (Integer) this.update(this.getStatementHandler(), sql, HandlersConstants.UPDATE_ROW_COUNT_HANDLER, HandlersConstants.EMPTY_QUERY_PARAMS); return rows.intValue(); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); QueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); int[] batch(String sql, Object[][] params); int[] batch(InputHandler[] inputHandlers); T query(String sql, OutputHandler<T> outputHandler, Object... params); T query(InputHandler inputHandler, OutputHandler<T> outputHandler); T query(String sql, OutputHandler<T> outputHandler); int update(String sql); int update(String sql, Object param); int update(String sql, Object... params); int update(InputHandler inputHandler); T update(InputHandler inputHandler, OutputHandler<T> outputHandler); T update(String sql, OutputHandler<T> outputHandler, Object... params); T execute(AbstractXmlInputOutputHandler<T> inputHandler); QueryParameters call(AbstractQueryInputHandler inputHandler); T call(AbstractNamedInputHandler<T> inputHandler, String catalog, String schema, boolean useCache); T call(AbstractNamedInputHandler<T> inputHandler); CallResults call(InputHandler<T> inputHandler, OutputHandler<S> outputHandler, String catalog, String schema, boolean useCache); CallResults call(InputHandler<T> inputHandler, OutputHandler<S> outputHandler); } | @Test(expected = java.sql.SQLException.class) public void testUpdate1SqlNull() throws Exception { queryRunner.update((String) null); }
@Test public void testUpdate2Value() throws Exception { queryRunner.update("SQL", "bla"); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(any(String.class)); verify(preparedStatement, times(1)).executeUpdate(); verify(statementHandler, times(1)).setStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, never()).readStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, times(1)).wrap(any(Statement.class)); verify(statementHandler, times(1)).beforeClose(); verify(statementHandler, times(1)).afterClose(); verify(metadataHandler, never()).getProcedureParameters(any(Connection.class), any(String.class), any(String.class), any(String.class), any(boolean.class)); }
@Test(expected = java.sql.SQLException.class) public void testUpdate2SqlNull() throws Exception { queryRunner.update(null, "bla"); }
@Test public void testUpdate2ParamNull() throws Exception { queryRunner.update("SQL", null); }
@Test public void testUpdate3Value() throws Exception { queryRunner.update("SQL", "", ""); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(any(String.class)); verify(preparedStatement, times(1)).executeUpdate(); verify(statementHandler, times(1)).setStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, never()).readStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, times(1)).wrap(any(Statement.class)); verify(statementHandler, times(1)).beforeClose(); verify(statementHandler, times(1)).afterClose(); verify(metadataHandler, never()).getProcedureParameters(any(Connection.class), any(String.class), any(String.class), any(String.class), any(boolean.class)); }
@Test(expected = java.sql.SQLException.class) public void testUpdate3SqlNull() throws Exception { queryRunner.update(null, "", ""); }
@Test(expected = java.sql.SQLException.class) public void testUpdate3ParamNull() throws Exception { queryRunner.update("SQL", null, null); }
@Test public void testUpdate4Value() throws Exception { queryRunner.update(new QueryInputHandler("SELECT :value", new QueryParameters().set("value", "bla"))); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(any(String.class)); verify(preparedStatement, times(1)).executeUpdate(); verify(statementHandler, times(1)).setStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, never()).readStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, times(1)).wrap(any(Statement.class)); verify(statementHandler, times(1)).beforeClose(); verify(statementHandler, times(1)).afterClose(); verify(metadataHandler, never()).getProcedureParameters(any(Connection.class), any(String.class), any(String.class), any(String.class), any(boolean.class)); }
@Test(expected = IllegalArgumentException.class) public void testUpdate4SqlNull() throws Exception { queryRunner.update(new QueryInputHandler(null, new QueryParameters())); }
@Test(expected = IllegalArgumentException.class) public void testUpdate4ParamNull() throws Exception { queryRunner.update(new QueryInputHandler("SELECT :value", null)); }
@Test public void testUpdate5Value() throws Exception { queryRunner.update(new QueryInputHandler("SELECT :value", new QueryParameters().set("value", "bla")), new MapOutputHandler()); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(any(String.class), any(int.class)); verify(preparedStatement, times(1)).executeUpdate(); verify(statementHandler, times(1)).setStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, never()).readStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, times(1)).wrap(any(Statement.class)); verify(statementHandler, times(1)).beforeClose(); verify(statementHandler, times(1)).afterClose(); verify(metadataHandler, never()).getProcedureParameters(any(Connection.class), any(String.class), any(String.class), any(String.class), any(boolean.class)); }
@Test(expected = IllegalArgumentException.class) public void testUpdate5SqlNull() throws Exception { queryRunner.update(new QueryInputHandler(null, new QueryParameters().set("value", "bla")), new MapOutputHandler()); }
@Test(expected = IllegalArgumentException.class) public void testUpdate5ParamNull() throws Exception { queryRunner.update(new QueryInputHandler("SELECT :value", null), new MapOutputHandler()); }
@Test public void testUpdate6Value() throws Exception { queryRunner.update("", new MapOutputHandler(), new Object[]{""}); verify(transactionHandler, times(1)).getConnection(); verify(transactionHandler, times(1)).commit(); verify(transactionHandler, times(1)).closeConnection(); verify(conn, times(1)).prepareStatement(any(String.class), any(int.class)); verify(preparedStatement, times(1)).executeUpdate(); verify(statementHandler, times(1)).setStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, never()).readStatement(any(Statement.class), any(QueryParameters.class)); verify(statementHandler, times(1)).wrap(any(Statement.class)); verify(statementHandler, times(1)).beforeClose(); verify(statementHandler, times(1)).afterClose(); verify(metadataHandler, never()).getProcedureParameters(any(Connection.class), any(String.class), any(String.class), any(String.class), any(boolean.class)); }
@Test(expected = java.sql.SQLException.class) public void testUpdate6SqlNull() throws Exception { queryRunner.update(null, new MapOutputHandler(), new Object[]{""}); }
@Test(expected = java.sql.SQLException.class) public void testUpdate6ParamNull() throws Exception { queryRunner.update("", null, new Object[]{""}); }
@Test public void testUpdateLazy() throws SQLException { ((QueryRunner) queryRunner).setStatementHandler(new LazyStatementHandler(new Overrider())); when(transactionHandler.getManualMode()).thenReturn(true); queryRunner.update("", new MapLazyOutputHandler(), new Object[]{""}); }
@Test(expected = MjdbcRuntimeException.class) public void testUpdateLazyException() throws SQLException { ((QueryRunner) queryRunner).setStatementHandler(new LazyStatementHandler(new Overrider())); queryRunner.update("", new MapLazyOutputHandler(), new Object[]{""}); } |
BaseStatementHandler implements StatementHandler { public void setStatement(Statement statement, QueryParameters params) throws SQLException { AssertUtils.assertNotNull(params); PreparedStatement preparedStmt = (PreparedStatement) statement; ParameterMetaData pmd = null; int stmtCount = -1; int paramsCount = params == null ? 0 : params.orderSize(); try { if (useMetadata == true) { pmd = preparedStmt.getParameterMetaData(); stmtCount = pmd.getParameterCount(); } else { stmtCount = paramsCount; } } catch (Exception ex) { useMetadata = false; stmtCount = paramsCount; } if (stmtCount != paramsCount) { if (this.overrider.hasOverride(MjdbcConstants.OVERRIDE_CONTROL_PARAM_COUNT) == true) { this.overrider.getOverride(MjdbcConstants.OVERRIDE_CONTROL_PARAM_COUNT); throw new SQLException("Wrong number of parameters: expected " + stmtCount + ", was given " + paramsCount); } else { logger.warning("Wrong number of parameters: expected " + stmtCount + ", was given " + paramsCount); } } if (params == null) { return; } String parameterName = null; Object parameterValue = null; Integer parameterType = null; for (int i = 0; i < params.orderSize(); i++) { parameterName = params.getNameByPosition(i); parameterValue = params.getValue(parameterName); parameterType = params.getType(parameterName); if (params.isInParameter(parameterName) == true) { if (parameterValue != null) { if (parameterType != null && parameterType.intValue() != MjdbcTypes.OTHER) { try { if (parameterType.intValue() == MjdbcTypes.VARCHAR && parameterValue instanceof Reader) { MappingUtils.invokeFunction(preparedStmt, "setCharacterStream", new Class[]{int.class, Reader.class}, new Object[]{i + 1, parameterValue}); } else if (parameterType.intValue() == MjdbcTypes.VARBINARY && parameterValue instanceof InputStream) { MappingUtils.invokeFunction(preparedStmt, "setBinaryStream", new Class[]{int.class, InputStream.class}, new Object[]{i + 1, parameterValue}); } else { preparedStmt.setObject(i + 1, parameterValue, parameterType); } } catch (MjdbcException ex) { preparedStmt.setObject(i + 1, parameterValue, parameterType); } } else { preparedStmt.setObject(i + 1, parameterValue); } } else { int sqlType = MjdbcTypes.VARCHAR; if (useMetadata == true) { try { sqlType = pmd.getParameterType(i + 1); } catch (SQLException e) { useMetadata = false; } } preparedStmt.setNull(i + 1, sqlType); } } } } BaseStatementHandler(Overrider overrider); void setStatement(Statement statement, QueryParameters params); List<QueryParameters> wrap(Statement stmt); Object[] readStatement(Statement statement, QueryParameters params); void beforeClose(); void afterClose(); } | @Test public void testSetStatement() throws Exception { invokeQueries(); verify(preparedStatement, times(3)).setObject(1, "luck"); verify(preparedStatement, times(3)).setNull(eq(2), any(int.class)); verify(preparedStatement, never()).setNull(eq(3), any(int.class)); verify(preparedStatement, never()).setObject(eq(3), any(String.class), any(int.class)); verify(callableStatement, times(1)).setObject(1, "luck"); verify(callableStatement, times(1)).setNull(eq(2), any(int.class)); verify(callableStatement, never()).setNull(eq(3), any(int.class)); verify(callableStatement, never()).setObject(eq(3), any(String.class)); } |
BaseStatementHandler implements StatementHandler { public List<QueryParameters> wrap(Statement stmt) throws SQLException { List<QueryParameters> mergedResult = new ArrayList<QueryParameters>(); List<QueryParameters> converted = null; ResultSet rs = null; List<ResultSet> closedResultSet = new ArrayList<ResultSet>(); QueryParameters statementParams = new QueryParameters(); statementParams.set(HandlersConstants.STMT_UPDATE_COUNT, stmt.getUpdateCount()); mergedResult.add(statementParams); if ((Integer) statementParams.getValue(HandlersConstants.STMT_UPDATE_COUNT) > 0 && this.overrider.hasOverride(MjdbcConstants.OVERRIDE_INT_GET_GENERATED_KEYS) == true) { this.overrider.getOverride(MjdbcConstants.OVERRIDE_INT_GET_GENERATED_KEYS); rs = stmt.getGeneratedKeys(); if (rs != null) { converted = MappingUtils.convertResultSet(rs); mergedResult.addAll(converted); MjdbcUtils.closeQuietly(rs); closedResultSet.add(rs); } } rs = stmt.getResultSet(); while (rs != null) { if (closedResultSet.contains(rs) == false) { converted = MappingUtils.convertResultSet(rs); mergedResult.addAll(converted); MjdbcUtils.closeQuietly(rs); closedResultSet.add(rs); } if (stmt.getMoreResults() == true) { rs = stmt.getResultSet(); } else { rs = null; } } return mergedResult; } BaseStatementHandler(Overrider overrider); void setStatement(Statement statement, QueryParameters params); List<QueryParameters> wrap(Statement stmt); Object[] readStatement(Statement statement, QueryParameters params); void beforeClose(); void afterClose(); } | @Test public void testWrap() throws Exception { invokeQueries(); verify(preparedStatement, times(2)).getUpdateCount(); verify(preparedStatement, times(2)).getGeneratedKeys(); verify(preparedStatement, times(2)).getResultSet(); verify(callableStatement, times(1)).getUpdateCount(); verify(callableStatement, times(1)).getGeneratedKeys(); verify(callableStatement, times(1)).getResultSet(); } |
QueryRunner extends AbstractQueryRunner { public QueryParameters call(AbstractQueryInputHandler inputHandler) throws SQLException { return callInner(inputHandler, null); } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); QueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); int[] batch(String sql, Object[][] params); int[] batch(InputHandler[] inputHandlers); T query(String sql, OutputHandler<T> outputHandler, Object... params); T query(InputHandler inputHandler, OutputHandler<T> outputHandler); T query(String sql, OutputHandler<T> outputHandler); int update(String sql); int update(String sql, Object param); int update(String sql, Object... params); int update(InputHandler inputHandler); T update(InputHandler inputHandler, OutputHandler<T> outputHandler); T update(String sql, OutputHandler<T> outputHandler, Object... params); T execute(AbstractXmlInputOutputHandler<T> inputHandler); QueryParameters call(AbstractQueryInputHandler inputHandler); T call(AbstractNamedInputHandler<T> inputHandler, String catalog, String schema, boolean useCache); T call(AbstractNamedInputHandler<T> inputHandler); CallResults call(InputHandler<T> inputHandler, OutputHandler<S> outputHandler, String catalog, String schema, boolean useCache); CallResults call(InputHandler<T> inputHandler, OutputHandler<S> outputHandler); } | @Test(expected = IllegalArgumentException.class) public void testCall1SqlNull() throws Exception { queryRunner.call(new MapInputHandler(null, new HashMap<String, Object>() {{ put("value", "bla"); }})); }
@Test(expected = IllegalArgumentException.class) public void testCall1SqlIncorrect() throws Exception { queryRunner.call(new MapInputHandler("", new HashMap<String, Object>() {{ put("value", "bla"); }})); }
@Test(expected = java.sql.SQLException.class) public void testCall1InputNull() throws Exception { queryRunner.call((AbstractNamedInputHandler) null); }
@Test(expected = IllegalArgumentException.class) public void testCall1ParamNull() throws Exception { queryRunner.call(new MapInputHandler("{CALL something(:value)}", null)); }
@Test(expected = IllegalArgumentException.class) public void testCall2SqlNull() throws Exception { queryRunner.call(new MapInputHandler(null, new HashMap<String, Object>() {{ put("value", "bla"); }}), "", "", false); }
@Test(expected = IllegalArgumentException.class) public void testCall2SqlIncorrect() throws Exception { queryRunner.call(new MapInputHandler("", new HashMap<String, Object>() {{ put("value", "bla"); }}), "", "", false); }
@Test(expected = IllegalArgumentException.class) public void testCall2ParamNull() throws Exception { queryRunner.call(new MapInputHandler("{CALL something(:value)}", null), "", "", false); }
@Test(expected = java.sql.SQLException.class) public void testCall2InputNull() throws Exception { queryRunner.call((AbstractNamedInputHandler) null, "", "", false); }
@Test(expected = IllegalArgumentException.class) public void testCall3SqlNull() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>(null, new Superhero("not_me"))); }
@Test(expected = IllegalArgumentException.class) public void testCall3SqlIncorrect() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>("", new Superhero("not_me"))); }
@Test(expected = IllegalArgumentException.class) public void testCall3ParamNull() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>("CALL something(:name)", null)); }
@Test(expected = java.sql.SQLException.class) public void testCall3InputNull() throws Exception { queryRunner.call((AbstractNamedInputHandler<String>) null); }
@Test(expected = IllegalArgumentException.class) public void testCall4SqlNull() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>(null, new Superhero("not_me")), "", "", false); }
@Test(expected = IllegalArgumentException.class) public void testCall4SqlIncorrect() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>("", new Superhero("not_me")), "", "", false); }
@Test(expected = IllegalArgumentException.class) public void testCall4ParamNull() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>("CALL something(:name)", null), "", "", false); }
@Test(expected = java.sql.SQLException.class) public void testCall4InputNull() throws Exception { queryRunner.call((AbstractNamedInputHandler<String>) null, "", "", false); }
@Test(expected = IllegalArgumentException.class) public void testCall5SqlNull() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>(null, new Superhero("not_me")), new MapOutputHandler(), "", "", false); }
@Test(expected = IllegalArgumentException.class) public void testCall5SqlIncorrect() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>("", new Superhero("not_me")), new MapOutputHandler(), "", "", false); }
@Test(expected = IllegalArgumentException.class) public void testCall5ParamNull() throws Exception { queryRunner.call(new BeanInputHandler<Superhero>("CALL something(:name)", null), new MapOutputHandler(), "", "", false); }
@Test(expected = java.sql.SQLException.class) public void testCall5InputNull() throws Exception { queryRunner.call((AbstractNamedInputHandler<String>) null, new MapOutputHandler(), "", "", false); }
@Test public void testCallLazy() throws SQLException { ((QueryRunner) queryRunner).setStatementHandler(new LazyStatementHandler(new Overrider())); when(transactionHandler.getManualMode()).thenReturn(true); when(statementHandler.readStatement(any(Statement.class), any(QueryParameters.class))).thenReturn(new Object[]{}); queryRunner.call(new BeanInputHandler<Superhero>("CALL something()", new Superhero()), new MapLazyOutputHandler()); }
@Test(expected = MjdbcRuntimeException.class) public void testCallLazyException() throws SQLException { ((QueryRunner) queryRunner).setStatementHandler(new LazyStatementHandler(new Overrider())); when(statementHandler.readStatement(any(Statement.class), any(QueryParameters.class))).thenReturn(new Object[]{}); queryRunner.call(new BeanInputHandler<Superhero>("CALL something()", new Superhero()), new MapLazyOutputHandler()); } |
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(); } | @Test public void testReadStatement() throws Exception { } |
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(); } | @Test public void testBeforeClose() throws Exception { } |
QueryRunner extends AbstractQueryRunner { public <T> T execute(AbstractXmlInputOutputHandler<T> inputHandler) throws SQLException { T result = null; Overrider queryOverride = inputHandler.getOverrides(); String operationType = (String) queryOverride.getOverride(XmlParameters.operationType); if (queryOverride.hasOverride(XmlParameters.generateKeys) == true) { this.overrideOnce(MjdbcConstants.OVERRIDE_INT_GET_GENERATED_KEYS, Boolean.valueOf((String) queryOverride.getOverride(XmlParameters.generateKeys))); } if (queryOverride.hasOverride(XmlParameters.generateKeysColumns) == true) { this.overrideOnce(MjdbcConstants.OVERRIDE_GENERATED_COLUMN_NAMES, queryOverride.getOverride(XmlParameters.generateKeysColumns)); } if (queryOverride.hasOverride(XmlParameters.controlParamCount) == true) { this.overrideOnce(MjdbcConstants.OVERRIDE_CONTROL_PARAM_COUNT, Boolean.valueOf((String) queryOverride.getOverride(XmlParameters.controlParamCount))); } if ("update".equals(operationType) == true) { result = update(inputHandler, inputHandler); } else if ("query".equals(operationType) == true) { result = query(inputHandler, inputHandler); } else { throw new MjdbcRuntimeException("Received operation is not supported: " + operationType); } return result; } QueryRunner(DataSource ds); QueryRunner(Connection conn); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(DataSource ds, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); QueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz); QueryRunner(Connection conn, Class<? extends TypeHandler> typeHandlerClazz, Class<? extends StatementHandler> statementHandlerClazz); int[] batch(String sql, Object[][] params); int[] batch(InputHandler[] inputHandlers); T query(String sql, OutputHandler<T> outputHandler, Object... params); T query(InputHandler inputHandler, OutputHandler<T> outputHandler); T query(String sql, OutputHandler<T> outputHandler); int update(String sql); int update(String sql, Object param); int update(String sql, Object... params); int update(InputHandler inputHandler); T update(InputHandler inputHandler, OutputHandler<T> outputHandler); T update(String sql, OutputHandler<T> outputHandler, Object... params); T execute(AbstractXmlInputOutputHandler<T> inputHandler); QueryParameters call(AbstractQueryInputHandler inputHandler); T call(AbstractNamedInputHandler<T> inputHandler, String catalog, String schema, boolean useCache); T call(AbstractNamedInputHandler<T> inputHandler); CallResults call(InputHandler<T> inputHandler, OutputHandler<S> outputHandler, String catalog, String schema, boolean useCache); CallResults call(InputHandler<T> inputHandler, OutputHandler<S> outputHandler); } | @Test(expected = MjdbcRuntimeException.class) public void testExecuteException1() throws SQLException { Overrider overrider1 = new Overrider(); overrider1.override(XmlParameters.operationType, "call"); when(xmlInputOutputHandler.getOverrides()).thenReturn(overrider1); queryRunner.execute(xmlInputOutputHandler); }
@Test(expected = MjdbcRuntimeException.class) public void testExecuteException2() throws SQLException { when(xmlInputOutputHandler.getOverrides()).thenReturn(new Overrider()); queryRunner.execute(xmlInputOutputHandler); }
@Test public void testExecute1() throws SQLException, MjdbcException { Overrider overrider1 = new Overrider(); overrider1.override(XmlParameters.operationType, "query"); when(xmlInputOutputHandler.getOverrides()).thenReturn(overrider1); when(xmlInputOutputHandler.getQueryString()).thenReturn(""); when(xmlInputOutputHandler.getQueryParameters()).thenReturn(new QueryParameters()); when(xmlInputOutputHandler.handle(any(List.class))).thenReturn(null); queryRunner.execute(xmlInputOutputHandler); verify(xmlInputOutputHandler, times(1)).getOverrides(); verify(xmlInputOutputHandler, times(1)).getQueryString(); verify(xmlInputOutputHandler, times(1)).getQueryParameters(); verify(xmlInputOutputHandler, times(1)).handle(any(List.class)); } |
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(); } | @Test public void testAfterClose() throws Exception { } |
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); } | @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); } |
BasicQueryOutputProcessor implements QueryOutputProcessor { public List<Object[]> toArrayList(List<QueryParameters> paramsList) { List<Object[]> result = new ArrayList<Object[]>(); QueryParameters singleParam = null; Object[] singleResult = null; String parameterName = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } while (iterator.hasNext() == true) { singleParam = iterator.next(); singleResult = new Object[singleParam.size()]; for (int j = 0; j < singleParam.size(); j++) { parameterName = singleParam.getNameByPosition(j); singleResult[j] = singleParam.getValue(parameterName); } result.add(singleResult); } 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); } | @Test public void testToArrayList() throws Exception { QueryParameters params = null; Object[] expected = new Object[]{"8", "7", "4"}; params = new QueryParameters(); params.set("intelligence", expected[0]); params.set("charisma", expected[1]); params.set("strength", expected[2]); paramsList.add(params); params = new QueryParameters(); params.set("perception", expected[0]); params.set("agility", expected[2]); params.set("luck", expected[1]); paramsList.add(params); List<Object[]> result = queryOutputProcessor.toArrayList(paramsList); Assert.assertEquals(3, result.get(0).length); org.junit.Assert.assertArrayEquals(expected, result.get(0)); Assert.assertEquals(3, result.get(1).length); org.junit.Assert.assertArrayEquals(new Object[]{expected[0], expected[2], expected[1]}, result.get(1)); } |
BasicQueryOutputProcessor implements QueryOutputProcessor { public <T> List<T> toBeanList(List<QueryParameters> paramsList, Class<T> type) throws MjdbcException { List<T> result = new ArrayList<T>(); T bean = null; int[] columnToProperty = null; PropertyDescriptor[] props = MappingUtils.propertyDescriptors(type); QueryParameters singleParam = null; Iterator<QueryParameters> iterator = paramsList.iterator(); if (iterator.hasNext() == true) { iterator.next(); } while (iterator.hasNext() == true) { singleParam = iterator.next(); columnToProperty = this.mapColumnsToProperties(singleParam, props); bean = this.createBean(singleParam, type, props, columnToProperty); result.add(bean); } 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); } | @Test public void testToBeanList() 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<Cat> result = null; result = queryOutputProcessor.toBeanList(paramsList, Cat.class); Assert.assertEquals(age1, result.get(0).getAge()); Assert.assertEquals(name1, result.get(0).getName()); Assert.assertEquals(age2, result.get(1).getAge()); Assert.assertEquals(name2, result.get(1).getName()); } |
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); } | @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")); } |
BasicQueryOutputProcessor implements QueryOutputProcessor { public Object processValue(QueryParameters params, Integer position, PropertyDescriptor prop) throws MjdbcException { String parameterName = params.getNameByPosition(position); Object value = params.getValue(parameterName); Class<?> propType = prop.getPropertyType(); final String targetType = propType.getName(); Object result = null; if (propType.isPrimitive() != true && value == null) { result = null; } else { if (value instanceof java.util.Date) { if ("java.sql.Date".equals(targetType)) { result = new java.sql.Date(((java.util.Date) value).getTime()); } else if ("java.sql.Time".equals(targetType)) { result = new java.sql.Time(((java.util.Date) value).getTime()); } else if ("java.sql.Timestamp".equals(targetType)) { result = new java.sql.Timestamp(((java.util.Date) value).getTime()); } } else if (value instanceof BigDecimal) { if ("java.lang.Integer".equals(targetType)) { result = ((BigDecimal) value).intValue(); } else if ("java.lang.Long".equals(targetType)) { result = ((BigDecimal) value).longValue(); } else if ("java.lang.Float".equals(targetType)) { result = ((BigDecimal) value).floatValue(); } else if ("java.lang.Double".equals(targetType)) { result = ((BigDecimal) value).doubleValue(); } else { throw new MjdbcException( "Cannot set " + prop.getName() + ": incompatible types, cannot convert " + value.getClass().getName() + " to " + propType.getName()); } } else if (value instanceof BigInteger) { if ("java.lang.Integer".equals(targetType)) { result = ((BigInteger) value).intValue(); } else if ("java.lang.Long".equals(targetType)) { result = ((BigInteger) value).longValue(); } else if ("java.lang.Float".equals(targetType)) { result = ((BigInteger) value).floatValue(); } else if ("java.lang.Double".equals(targetType)) { result = ((BigInteger) value).doubleValue(); } else { throw new MjdbcException( "Cannot set " + prop.getName() + ": incompatible types, cannot convert " + value.getClass().getName() + " to " + propType.getName()); } } else { result = value; } } if (this.isCompatibleType(value, propType) == false) { throw new MjdbcException( "Cannot set " + prop.getName() + ": incompatible types, cannot convert " + value.getClass().getName() + " to " + propType.getName()); } 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); } | @Test public void testProcessValue() throws Exception { long expectedTime = 100; java.util.Date resultTime = null; QueryParameters params = new QueryParameters(); params.set("date", new Date(expectedTime)); params.set("time", new Time(expectedTime + 10)); params.set("timestamp", new Timestamp(expectedTime + 20)); params.set("bigdecimal", new BigDecimal("10.10")); params.set("bigInteger", new BigInteger("11")); PropertyDescriptor props[] = MappingUtils.propertyDescriptors(SQLValues.class); Long bigInteger = (Long) queryOutputProcessor.processValue(params, 4, props[1]); Assert.assertEquals(bigInteger.longValue(), 11); Double bigDecimal = (Double) queryOutputProcessor.processValue(params, 3, props[0]); Assert.assertEquals(bigDecimal.doubleValue(), 10, 10); resultTime = (java.util.Date) queryOutputProcessor.processValue(params, 0, props[3]); Assert.assertEquals(resultTime.getTime(), expectedTime); resultTime = (java.util.Date) queryOutputProcessor.processValue(params, 1, props[4]); Assert.assertEquals(resultTime.getTime(), expectedTime + 10); resultTime = (java.util.Date) queryOutputProcessor.processValue(params, 2, props[5]); Assert.assertEquals(resultTime.getTime(), expectedTime + 20); try { queryOutputProcessor.processValue(params, 1, props[5]); fail(); } catch (MjdbcException ex) { Assert.assertEquals("Cannot set timestamp: incompatible types, cannot convert java.sql.Time to java.sql.Timestamp", ex.getMessage()); } } |
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); } | @Test public void testToMapNull() { Assert.assertEquals(null, queryOutputProcessor.toMap((QueryParameters) null)); } |
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); } | @Test public void testToBeanNull() throws MjdbcException { Assert.assertEquals(null, queryOutputProcessor.toBean((QueryParameters) null, Cat.class)); } |
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); } | @Test public void testGetDefaultQueryInputProcessor() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultQueryInputProcessor() instanceof QueryInputProcessor); } |
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); } | @Test public void testIsQueryInputProcessorUseCache() throws Exception { boolean defaultValue = MidaoConfig.isQueryInputProcessorUseCache(); MidaoConfig.setQueryInputProcessorUseCache(!defaultValue); Assert.assertEquals(!defaultValue, MidaoConfig.isQueryInputProcessorUseCache()); MidaoConfig.setQueryInputProcessorUseCache(defaultValue); } |
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); } | @Test public void testGetDefaultQueryOutputProcessor() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultQueryOutputProcessor() instanceof QueryOutputProcessor); } |
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(); } | @Test public void testGetDefaultQueryInputProcessor() throws Exception { Assert.assertEquals(true, MjdbcConfig.getDefaultQueryInputProcessor() instanceof QueryInputProcessor); } |
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); } | @Test public void testGetDefaultStatementHandler() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultStatementHandler(overrider) instanceof StatementHandler); } |
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); } | @Test public void testGetDefaultTypeHandler() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultTypeHandler(overrider) instanceof TypeHandler); } |
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); } | @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); } |
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); } | @Test public void testGetDefaultExceptionHandler() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultExceptionHandler("") instanceof ExceptionHandler); } |
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); } | @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); } |
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); } | @Test public void testGetDefaultOverrider() throws Exception { Assert.assertEquals(true, MidaoConfig.getDefaultOverrider() instanceof Overrider); } |
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); } | @Test public void testIsProfilerEnabled() throws Exception { boolean defaultValue = MidaoConfig.isProfilerEnabled(); MidaoConfig.setProfilerEnabled(!defaultValue); Assert.assertEquals(!defaultValue, MidaoConfig.isProfilerEnabled()); MidaoConfig.setProfilerEnabled(defaultValue); } |
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); } | @Test public void testGetProfilerOutputFormat() throws Exception { Assert.assertEquals(true, MidaoConfig.getProfilerOutputFormat() != null && MidaoConfig.getProfilerOutputFormat().length() > 0); } |
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(); } | @Test public void testIsQueryInputProcessorUseCache() throws Exception { boolean defaultValue = MjdbcConfig.isQueryInputProcessorUseCache(); MjdbcConfig.setQueryInputProcessorUseCache(!defaultValue); Assert.assertEquals(!defaultValue, MjdbcConfig.isQueryInputProcessorUseCache()); MjdbcConfig.setQueryInputProcessorUseCache(defaultValue); } |
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(); } | @Test public void testGetDefaultQueryOutputProcessor() throws Exception { Assert.assertEquals(true, MjdbcConfig.getDefaultQueryOutputProcessor() instanceof QueryOutputProcessor); } |
MjdbcConfig { public static StatementHandler getDefaultStatementHandler(Overrider overrider) { StatementHandler result = null; Constructor<? extends StatementHandler> constructor = null; Class<? extends StatementHandler> clazz = instance().defaultStatementHandler; try { constructor = clazz.getConstructor(Overrider.class); result = constructor.newInstance(overrider); } catch (SecurityException e) { throw new MjdbcRuntimeException(ERROR_SH_INIT_FAILED, e); } catch (NoSuchMethodException e) { throw new MjdbcRuntimeException(ERROR_SH_INIT_FAILED, e); } catch (IllegalArgumentException e) { throw new MjdbcRuntimeException(ERROR_SH_INIT_FAILED, e); } catch (InstantiationException e) { throw new MjdbcRuntimeException(ERROR_SH_INIT_FAILED, e); } catch (IllegalAccessException e) { throw new MjdbcRuntimeException(ERROR_SH_INIT_FAILED, e); } catch (InvocationTargetException e) { throw new MjdbcRuntimeException(ERROR_SH_INIT_FAILED, e); } return result; } 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(); } | @Test public void testGetDefaultStatementHandler() throws Exception { Assert.assertEquals(true, MjdbcConfig.getDefaultStatementHandler(overrider) instanceof StatementHandler); } |
MjdbcConfig { public static TypeHandler getDefaultTypeHandler(Overrider overrider) { TypeHandler result = null; Constructor<? extends TypeHandler> constructor = null; Class<? extends TypeHandler> clazz = instance().defaultTypeHandler; try { constructor = clazz.getConstructor(Overrider.class); result = constructor.newInstance(overrider); } catch (SecurityException e) { throw new MjdbcRuntimeException(ERROR_TyH_INIT_FAILED, e); } catch (NoSuchMethodException e) { throw new MjdbcRuntimeException(ERROR_TyH_INIT_FAILED, e); } catch (IllegalArgumentException e) { throw new MjdbcRuntimeException(ERROR_TyH_INIT_FAILED, e); } catch (InstantiationException e) { throw new MjdbcRuntimeException(ERROR_TyH_INIT_FAILED, e); } catch (IllegalAccessException e) { throw new MjdbcRuntimeException(ERROR_TyH_INIT_FAILED, e); } catch (InvocationTargetException e) { throw new MjdbcRuntimeException(ERROR_TyH_INIT_FAILED, e); } return result; } 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(); } | @Test public void testGetDefaultTypeHandler() throws Exception { Assert.assertEquals(true, MjdbcConfig.getDefaultTypeHandler(overrider) instanceof TypeHandler); } |
MjdbcConfig { public static TransactionHandler getDefaultTransactionHandler(Connection conn) { TransactionHandler result = null; Constructor<?> constructor = null; Class<?> clazz = instance().defaultTransactionHandler; try { constructor = clazz.getConstructor(Connection.class); result = (TransactionHandler) constructor.newInstance(conn); } catch (SecurityException e) { throw new MjdbcRuntimeException(ERROR_TH_INIT_FAILED, e); } catch (NoSuchMethodException e) { throw new MjdbcRuntimeException(ERROR_TH_INIT_FAILED, e); } catch (IllegalArgumentException e) { throw new MjdbcRuntimeException(ERROR_TH_INIT_FAILED, e); } catch (InstantiationException e) { throw new MjdbcRuntimeException(ERROR_TH_INIT_FAILED, e); } catch (IllegalAccessException e) { throw new MjdbcRuntimeException(ERROR_TH_INIT_FAILED, e); } catch (InvocationTargetException e) { throw new MjdbcRuntimeException(ERROR_TH_INIT_FAILED, e); } return result; } 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(); } | @Test public void testGetDefaultTransactionHandlerConn() throws Exception { Assert.assertEquals(true, MjdbcConfig.getDefaultTransactionHandler(conn) instanceof TransactionHandler); }
@Test public void testGetDefaultTransactionHandlerDataSource() throws Exception { Assert.assertEquals(true, MjdbcConfig.getDefaultTransactionHandler(ds) instanceof TransactionHandler); } |
MjdbcConfig { public static ExceptionHandler getDefaultExceptionHandler(String dbName) { ExceptionHandler result = null; Constructor<?> constructor = null; Class<?> clazz = instance().defaultExceptionHandler; try { constructor = clazz.getConstructor(String.class); result = (ExceptionHandler) constructor.newInstance(dbName); } catch (SecurityException e) { throw new MjdbcRuntimeException(ERROR_TH_INIT_FAILED, e); } catch (NoSuchMethodException e) { throw new MjdbcRuntimeException(ERROR_TH_INIT_FAILED, e); } catch (IllegalArgumentException e) { throw new MjdbcRuntimeException(ERROR_TH_INIT_FAILED, e); } catch (InstantiationException e) { throw new MjdbcRuntimeException(ERROR_TH_INIT_FAILED, e); } catch (IllegalAccessException e) { throw new MjdbcRuntimeException(ERROR_TH_INIT_FAILED, e); } catch (InvocationTargetException e) { throw new MjdbcRuntimeException(ERROR_TH_INIT_FAILED, e); } return result; } 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(); } | @Test public void testGetDefaultExceptionHandler() throws Exception { Assert.assertEquals(true, MjdbcConfig.getDefaultExceptionHandler("") instanceof ExceptionHandler); } |
MjdbcConfig { public static MetadataHandler getDefaultMetadataHandler(Connection conn) { MetadataHandler result = null; Constructor<?> constructor = null; Class<?> clazz = instance().defaultMetadataHandler; try { constructor = clazz.getConstructor(Connection.class, boolean.class); result = (MetadataHandler) constructor.newInstance(conn, false); } catch (SecurityException e) { throw new MjdbcRuntimeException(ERROR_MH_INIT_FAILED, e); } catch (NoSuchMethodException e) { throw new MjdbcRuntimeException(ERROR_MH_INIT_FAILED, e); } catch (IllegalArgumentException e) { throw new MjdbcRuntimeException(ERROR_MH_INIT_FAILED, e); } catch (InstantiationException e) { throw new MjdbcRuntimeException(ERROR_MH_INIT_FAILED, e); } catch (IllegalAccessException e) { throw new MjdbcRuntimeException(ERROR_MH_INIT_FAILED, e); } catch (InvocationTargetException e) { throw new MjdbcRuntimeException(ERROR_MH_INIT_FAILED, e); } return result; } 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(); } | @Test public void testGetDefaultMetadataHandlerConn() throws Exception { Assert.assertEquals(true, MjdbcConfig.getDefaultMetadataHandler(conn) instanceof MetadataHandler); }
@Test public void testGetDefaultMetadataHandlerDataSource() throws Exception { Assert.assertEquals(true, MjdbcConfig.getDefaultMetadataHandler(ds) instanceof MetadataHandler); } |
MjdbcConfig { public static Overrider getDefaultOverrider() { Overrider result = null; Class<Overrider> clazz = instance().defaultOverrider; try { result = clazz.newInstance(); } catch (InstantiationException e) { throw new MjdbcRuntimeException(ERROR_OR_INIT_FAILED, e); } catch (IllegalAccessException e) { throw new MjdbcRuntimeException(ERROR_OR_INIT_FAILED, e); } return result; } 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(); } | @Test public void testGetDefaultOverrider() throws Exception { Assert.assertEquals(true, MjdbcConfig.getDefaultOverrider() instanceof Overrider); } |
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(); } | @Test public void testIsProfilerEnabled() throws Exception { boolean defaultValue = MjdbcConfig.isProfilerEnabled(); MjdbcConfig.setProfilerEnabled(!defaultValue); Assert.assertEquals(!defaultValue, MjdbcConfig.isProfilerEnabled()); MjdbcConfig.setProfilerEnabled(defaultValue); } |
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(); } | @Test public void testGetProfilerOutputFormat() throws Exception { Assert.assertEquals(true, MjdbcConfig.getProfilerOutputFormat() != null && MjdbcConfig.getProfilerOutputFormat().length() > 0); } |
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); } | @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); } |
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); } | @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) { } } |
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); } | @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")); } |
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); } | @Test public void testIsAutoRefresh() throws Exception { } |
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); } | @Test public void testSetAutoRefresh() throws Exception { } |
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); } | @Test public void testGetQueryString() throws Exception { XmlRepositoryFactory.addAll(XmlRepositoryFactory.getDocument(new ByteArrayInputStream( xmlQuery.getBytes() ))); Assert.assertNotNull(XmlRepositoryFactory.getQueryString("findOne")); } |
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); } | @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)); } |
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); } | @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)); } |
QueryParametersLazyList implements List<QueryParameters> { public void setMaxCacheSize(int maxCacheSize) { if (maxCacheSize == 0) { this.maxCacheSize = 1; } else if (maxCacheSize < 0) { this.maxCacheSize = -1; } else { this.maxCacheSize = maxCacheSize; } } 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); } | @Test public void testSetMaxCacheSize() throws Exception { queryParametersLazyList.get(1); Assert.assertEquals(2, queryParametersLazyList.sizeCached()); queryParametersLazyList.setMaxCacheSize(1); queryParametersLazyList.get(2); Assert.assertEquals(2, queryParametersLazyList.sizeCached()); } |
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); } | @Test public void testGetAsyncQueryRunner() throws Exception { Assert.assertEquals(true, MidaoFactory.getAsyncQueryRunner(null, null) instanceof AsyncQueryRunner); } |
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); } | @Test public void testIsEmpty() throws Exception { Assert.assertEquals(false, queryParametersLazyList.isEmpty()); } |
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); } | @Test(expected = MjdbcRuntimeException.class) public void testSize() throws Exception { queryParametersLazyList.size(); } |
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); } | @Test public void testSizeCached() throws Exception { Assert.assertEquals(1, queryParametersLazyList.sizeCached()); queryParametersLazyList.get(1); queryParametersLazyList.get(2); Assert.assertEquals(3, queryParametersLazyList.sizeCached()); } |
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); } | @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]); } |
QueryParametersLazyList implements List<QueryParameters> { public Object[] toArrayCached() { Object[] readCacheArray = generatedCacheMap.values().toArray(); Object[] writeCacheArray = resultSetCacheMap.values().toArray(); Object[] combinedCacheArray = new Object[readCacheArray.length + writeCacheArray.length]; System.arraycopy(readCacheArray, 0, combinedCacheArray, 0, readCacheArray.length); System.arraycopy(writeCacheArray, 0, combinedCacheArray, readCacheArray.length, writeCacheArray.length); return combinedCacheArray; } 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); } | @Test public void testToArrayCached() throws Exception { Object[] result = queryParametersLazyList.toArrayCached(); Assert.assertEquals(1, result.length); queryParametersLazyList.get(1); queryParametersLazyList.get(2); result = queryParametersLazyList.toArrayCached(); Assert.assertEquals(3, result.length); Assert.assertEquals("Nightcrawler", ((QueryParameters) result[1]).getValue("name")); Assert.assertEquals("Lobo", ((QueryParameters) result[2]).getValue("name")); } |
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); } | @Test(expected = MjdbcRuntimeException.class) public void testSubList() throws Exception { queryParametersLazyList.subList(0, 2); } |
QueryParametersLazyList implements List<QueryParameters> { public List<QueryParameters> subListCached(int fromIndex, int toIndex) { ArrayList<QueryParameters> result = new ArrayList<QueryParameters>(); result.addAll(generatedCacheMap.values()); result.addAll(resultSetCacheMap.values()); return result.subList(fromIndex, toIndex); } 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); } | @Test public void testSubListCached() throws Exception { List<QueryParameters> result = null; try { result = queryParametersLazyList.subListCached(1, 3); fail(); } catch (IndexOutOfBoundsException ex) { } queryParametersLazyList.get(1); queryParametersLazyList.get(2); result = queryParametersLazyList.subListCached(1, 3); Assert.assertEquals(2, result.size()); Assert.assertEquals("Nightcrawler", result.get(0).getValue("name")); Assert.assertEquals("Lobo", result.get(1).getValue("name")); } |
QueryParametersLazyList implements List<QueryParameters> { public QueryParameters get(int index) { if (getCurrentResultSet() == null && index > 0 && valueCached(index) == false) { return null; } QueryParameters params = null; try { if (valueCached(index) == false) { if (this.type == Type.READ_ONLY_FORWARD && currentIndex >= index) { throw new MjdbcRuntimeException("Attempt to read current/previous value failed because it is not present in cache. " + "Please increase maximum cache size via overrider or MjdbcConfig."); } if (this.type == Type.READ_ONLY_FORWARD) { for (int i = currentIndex; i < index; i++) { params = null; do { params = convertResultSetNextLine(getCurrentResultSet()); if (params == null) { closeResultSet(getCurrentResultSet()); setCurrentResultSet(getNextResultSet()); } } while (params == null && getCurrentResultSet() != null); if (params != null) { updateCache(i + 1, params); currentIndex++; } else { if (getCurrentResultSet() == null) { break; } } } } else if (this.type == Type.READ_ONLY_SCROLL || this.type == Type.UPDATE_SCROLL) { params = readResultSetRow((index + 1) - generatedCacheMap.size()); if (params != null) { updateCache(index, params); } } } else { params = readCachedValue(index); } } catch (SQLException ex) { throw new MjdbcRuntimeException("Failed to read ResultSet", ex); } if (params == null) { } return params; } 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); } | @Test public void testGet() throws Exception { Assert.assertEquals("Nightcrawler", queryParametersLazyList.get(1).getValue("name")); Assert.assertEquals("Lobo", queryParametersLazyList.get(2).getValue("name")); Assert.assertEquals(null, queryParametersLazyList.get(3)); } |
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); } | @Test public void testClose() throws Exception { queryParametersLazyList.close(); verify(rs, times(1)).close(); verify(stmt, times(1)).close(); } |
QueryParametersLazyList implements List<QueryParameters> { public Iterator<QueryParameters> iterator() { final QueryParametersLazyList source = this; return new Iterator<QueryParameters>() { private LazyCacheIterator<QueryParameters> lazyCacheIterator = source.getLazyCacheIterator(-1); public boolean hasNext() { return lazyCacheIterator.hasNext(); } public QueryParameters next() { return lazyCacheIterator.getNext(); } public void remove() { source.remove(currentIndex); } }; } 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); } | @Test public void testIterator() throws Exception { Iterator<QueryParameters> iter = queryParametersLazyList.iterator(); iter.next(); Assert.assertEquals("Nightcrawler", iter.next().getValue("name")); Assert.assertEquals("Lobo", iter.next().getValue("name")); } |
QueryParametersLazyList implements List<QueryParameters> { public QueryParameters set(int index, QueryParameters element) { QueryParameters params = null; if (getMaxCacheSize() != -1) { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED + ". Cache update is allowed when Cache is not limited (used by Cached output handlers)"); } if (valueCached(index) == true) { params = readCachedValue(index); updateCache(index, element); } else { throw new MjdbcRuntimeException(ERROR_NOT_ALLOWED + ". Only cached(read) values can be replaced"); } return params; } 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); } | @Test public void testSet() throws Exception { QueryParameters paramsOriginal1 = null; QueryParameters paramsOriginal2 = null; QueryParameters paramsSet = new QueryParameters(); paramsOriginal1 = queryParametersLazyList.get(1); paramsOriginal2 = queryParametersLazyList.set(1, paramsSet); Assert.assertEquals(paramsOriginal1, paramsOriginal2); Assert.assertEquals(paramsSet, queryParametersLazyList.get(1)); } |
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); } | @Test(expected = MjdbcRuntimeException.class) public void testListIterator() throws Exception { queryParametersLazyList.listIterator(); }
@Test(expected = MjdbcRuntimeException.class) public void testListIteratorIndex() throws Exception { queryParametersLazyList.listIterator(1); } |
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); } | @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); } |
QueryParametersLazyList implements List<QueryParameters> { public boolean addAll(Collection<? extends QueryParameters> 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); } | @Test(expected = MjdbcRuntimeException.class) public void testAddAll() throws Exception { queryParametersLazyList.addAll(Arrays.<QueryParameters>asList(new QueryParameters[0])); }
@Test(expected = MjdbcRuntimeException.class) public void testAddAllIndex() throws Exception { queryParametersLazyList.addAll(1, Arrays.<QueryParameters>asList(new QueryParameters[0])); } |
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); } | @Test(expected = MjdbcRuntimeException.class) public void testRemove() throws Exception { queryParametersLazyList.remove(null); }
@Test(expected = MjdbcRuntimeException.class) public void testRemoveIndex() throws Exception { queryParametersLazyList.remove(1); } |
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); } | @Test(expected = MjdbcRuntimeException.class) public void testRemoveAll() throws Exception { queryParametersLazyList.removeAll(Arrays.<QueryParameters>asList(new QueryParameters[0])); } |
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); } | @Test(expected = MjdbcRuntimeException.class) public void testRetainAll() throws Exception { queryParametersLazyList.retainAll(Arrays.<QueryParameters>asList(new QueryParameters[0])); } |
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); } | @Test(expected = MjdbcRuntimeException.class) public void testClear() throws Exception { queryParametersLazyList.clear(); } |
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); } | @Test(expected = MjdbcRuntimeException.class) public void testContains() throws Exception { queryParametersLazyList.contains(null); } |
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); } | @Test(expected = MjdbcRuntimeException.class) public void testContainsAll() throws Exception { queryParametersLazyList.containsAll(Arrays.<QueryParameters>asList(new QueryParameters[0])); } |
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); } | @Test(expected = MjdbcRuntimeException.class) public void testIndexOf() throws Exception { queryParametersLazyList.indexOf(null); } |
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); } | @Test(expected = MjdbcRuntimeException.class) public void testLastIndexOf() throws Exception { queryParametersLazyList.lastIndexOf(null); } |
DefaultCallAdapterFactory extends CallAdapter.Factory { @Override public CallAdapter<?, ?> get(@Nonnull final Type returnType, @Nonnull final Annotation[] annotations, @Nonnull final Retrofit retrofit) { if (getRawType(returnType) != CompletableFuture.class) { return null; } if (!(returnType instanceof ParameterizedType)) { throw new IllegalStateException("CompletableFuture return type must be parameterized as" + " CompletableFuture<Foo> or CompletableFuture<? extends Foo>"); } final Type innerType = getParameterUpperBound(0, (ParameterizedType) returnType); return new CompletableFutureBasedCallAdapter<>(new ApiResponseType(innerType), retry, logger); } DefaultCallAdapterFactory(final boolean retry, @Nonnull final Logger logger); @Override CallAdapter<?, ?> get(@Nonnull final Type returnType, @Nonnull final Annotation[] annotations, @Nonnull final Retrofit retrofit); } | @Test public void testCreateAdapter() { DefaultCallAdapterFactory factory = new DefaultCallAdapterFactory(false, LOGGER); 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; } }; CallAdapter<?, ?> adapter = factory.get(returnType, new Annotation[0], null); assertNotNull(adapter); Type responseType = adapter.responseType(); assertTrue(responseType instanceof ParameterizedType); assertEquals(Object.class, ((ParameterizedType) responseType).getOwnerType()); assertEquals(ApiResponse.class, ((ParameterizedType) responseType).getRawType()); assertEquals(String.class, ((ParameterizedType) responseType).getActualTypeArguments()[0]); assertEquals(DefaultCallAdapterFactory.ApiResponseType.class, responseType.getClass()); }
@Test(expected = IllegalStateException.class) public void testNonParameterizedCompletableFuture() { DefaultCallAdapterFactory factory = new DefaultCallAdapterFactory(false, LOGGER); assertNull(factory.get(CompletableFuture.class, new Annotation[0], null)); }
@Test public void testUnsupportedReturnType() { DefaultCallAdapterFactory factory = new DefaultCallAdapterFactory(false, LOGGER); assertNull(factory.get(Object.class, new Annotation[0], null)); } |
NoOpBotUpdateProcessor implements BotUpdateProcessor { @Override public boolean handleUpdate(@Nonnull final Update update) { return true; } static NoOpBotUpdateProcessor getDefault(); @Override boolean handleUpdate(@Nonnull final Update update); } | @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); } |
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; } | @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--; } } |
CommandUtil { public static Command parseCommandFromText(final String text) { if (isNullOrEmpty(text) || !text.startsWith(CMD_PREFIX)) { return null; } String[] tmp = text.split(" ", 2); String argument = tmp.length > 1 ? tmp[1] : null; String cmdToBot = tmp[0].replaceFirst(CMD_PREFIX, ""); if (!CMD_PATTERN.matcher(cmdToBot).matches()) { return null; } tmp = cmdToBot.split("@", 2); final String type = tmp[0]; if (isNullOrEmpty(type)) { return null; } final String toBot = tmp.length > 1 ? tmp[1] : null; return new Command(type, toBot, argument); } static Command parseCommandFromText(final String text); } | @Test public void testParseCommand() { Command cmd; cmd = parseCommandFromText(null); assertNull(cmd); cmd = parseCommandFromText("\n"); assertNull(cmd); cmd = parseCommandFromText(" assertNull(cmd); cmd = parseCommandFromText("/ "); assertNull(cmd); cmd = parseCommandFromText("/ /aaa"); assertNull(cmd); cmd = parseCommandFromText("/@ /aaa"); assertNull(cmd); cmd = parseCommandFromText("/@bot /aaa"); assertNull(cmd); cmd = parseCommandFromText("/aaa@bbb ccc"); assertNull(cmd); cmd = parseCommandFromText("/hello"); assertNotNull(cmd); assertEquals("hello", cmd.type); assertNull(cmd.toBot); assertNull(cmd.argument); cmd = parseCommandFromText("/hello "); assertNotNull(cmd); assertEquals("hello", cmd.type); assertNull(cmd.toBot); assertEquals("", cmd.argument); cmd = parseCommandFromText("/hello Jarvis"); assertNotNull(cmd); assertEquals("hello", cmd.type); assertNull(cmd.toBot); assertEquals(cmd.argument, "Jarvis"); cmd = parseCommandFromText("/hello@enl_jarvis_bot"); assertNotNull(cmd); assertEquals("hello", cmd.type); assertEquals(cmd.toBot, "enl_jarvis_bot"); assertNull(cmd.argument); cmd = parseCommandFromText("/hello@enl_jarvis_bot "); assertNotNull(cmd); assertEquals("hello", cmd.type); assertEquals(cmd.toBot, "enl_jarvis_bot"); assertEquals("", cmd.argument); cmd = parseCommandFromText("/hello@enl_jarvis_bot Jarvis"); assertNotNull(cmd); assertEquals("hello", cmd.type); assertEquals(cmd.toBot, "enl_jarvis_bot"); assertEquals(cmd.argument, "Jarvis"); } |
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); } | @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(); } |
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; } | @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()); } } } |
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; } | @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()); } } } |
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); } | @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) { } } |
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); } | @Test public void testParseBotIdFromToken() { assertEquals("000", parseBotIdFromToken("000:bb")); } |
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); } | @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()); } |
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(); } | @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); } |
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; } | @Test public void onLoggedIn() { DigitalOcean.onLoggedIn("m31b5m13b1b23febm1513bj15hb"); } |
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(); } | @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()); } |
BitReaderBuffer { public int readBits(int i) { byte b = buffer.get(initialPos + position / 8); int v = b < 0 ? b + 256 : b; int left = 8 - position % 8; int rc; if (i <= left) { rc = (v << (position % 8) & 0xFF) >> ((position % 8) + (left - i)); position += i; } else { int now = left; int then = i - left; rc = readBits(now); rc = rc << then; rc += readBits(then); } buffer.position(initialPos + (int) Math.ceil((double) position / 8)); return rc; } BitReaderBuffer(ByteBuffer buffer); int readBits(int i); int getPosition(); int byteSync(); int remainingBits(); } | @Test public void testRead_8() { BitReaderBuffer bitReaderBuffer = new BitReaderBuffer(testSequence); Assert.assertEquals(15, bitReaderBuffer.readBits(4)); Assert.assertEquals(15, bitReaderBuffer.readBits(4)); Assert.assertEquals(0, bitReaderBuffer.readBits(4)); Assert.assertEquals(0, bitReaderBuffer.readBits(4)); }
@Test public void testReadCrossByte() { BitReaderBuffer bitReaderBuffer = new BitReaderBuffer(testSequence); Assert.assertEquals(31, bitReaderBuffer.readBits(5)); Assert.assertEquals(14, bitReaderBuffer.readBits(4)); Assert.assertEquals(0, bitReaderBuffer.readBits(3)); Assert.assertEquals(0, bitReaderBuffer.readBits(4)); }
@Test public void testReadMultiByte() { BitReaderBuffer bitReaderBuffer = new BitReaderBuffer(testSequence); Assert.assertEquals(510, bitReaderBuffer.readBits(9)); }
@Test public void testReadMultiByte2() { BitReaderBuffer bitReaderBuffer = new BitReaderBuffer(testSequence); Assert.assertEquals(0x1fe01, bitReaderBuffer.readBits(17)); }
@Test public void readFromTheMiddle() { ByteBuffer b = ByteBuffer.wrap(new byte[]{0, -1}); b.get(); BitReaderBuffer brb = new BitReaderBuffer(b); Assert.assertEquals(15, brb.readBits(4)); Assert.assertEquals(15, brb.readBits(4)); } |
BitReaderBuffer { public int remainingBits() { return buffer.limit() * 8 - position; } BitReaderBuffer(ByteBuffer buffer); int readBits(int i); int getPosition(); int byteSync(); int remainingBits(); } | @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()); } |
SyncSampleIntersectFinderImpl implements FragmentIntersectionFinder { public long[] sampleNumbers(Track track, Movie movie) { final CacheTuple key = new CacheTuple(track, movie); final long[] result = getSampleNumbersCache.get(key); if (result != null) { return result; } if ("vide".equals(track.getHandler())) { if (track.getSyncSamples() != null && track.getSyncSamples().length > 0) { List<long[]> times = getSyncSamplesTimestamps(movie, track); final long[] commonIndices = getCommonIndices(track.getSyncSamples(), getTimes(track, movie), track.getTrackMetaData().getTimescale(), times.toArray(new long[times.size()][])); getSampleNumbersCache.put(key, commonIndices); return commonIndices; } else { throw new RuntimeException("Video Tracks need sync samples. Only tracks other than video may have no sync samples."); } } else if ("soun".equals(track.getHandler())) { Track referenceTrack = null; for (Track candidate : movie.getTracks()) { if (candidate.getSyncSamples() != null && "vide".equals(candidate.getHandler()) && candidate.getSyncSamples().length > 0) { referenceTrack = candidate; } } if (referenceTrack != null) { long[] refSyncSamples = sampleNumbers(referenceTrack, movie); int refSampleCount = referenceTrack.getSamples().size(); long[] syncSamples = new long[refSyncSamples.length]; long minSampleRate = 192000; for (Track testTrack : movie.getTracks()) { if ("soun".equals(testTrack.getHandler())) { AudioSampleEntry ase = (AudioSampleEntry) testTrack.getSampleDescriptionBox().getSampleEntry(); if (ase.getSampleRate() < minSampleRate) { minSampleRate = ase.getSampleRate(); long sc = testTrack.getSamples().size(); double stretch = (double) sc / refSampleCount; TimeToSampleBox.Entry sttsEntry = testTrack.getDecodingTimeEntries().get(0); long samplesPerFrame = sttsEntry.getDelta(); for (int i = 0; i < syncSamples.length; i++) { long start = (long) Math.ceil(stretch * (refSyncSamples[i] - 1) * samplesPerFrame); syncSamples[i] = start; } break; } } } AudioSampleEntry ase = (AudioSampleEntry) track.getSampleDescriptionBox().getSampleEntry(); TimeToSampleBox.Entry sttsEntry = track.getDecodingTimeEntries().get(0); long samplesPerFrame = sttsEntry.getDelta(); double factor = (double) ase.getSampleRate() / (double) minSampleRate; if (factor != Math.rint(factor)) { throw new RuntimeException("Sample rates must be a multiple of the lowest sample rate to create a correct file!"); } for (int i = 0; i < syncSamples.length; i++) { syncSamples[i] = (long) (1 + syncSamples[i] * factor / (double) samplesPerFrame); } getSampleNumbersCache.put(key, syncSamples); return syncSamples; } throw new RuntimeException("There was absolutely no Track with sync samples. I can't work with that!"); } else { for (Track candidate : movie.getTracks()) { if (candidate.getSyncSamples() != null && candidate.getSyncSamples().length > 0) { long[] refSyncSamples = sampleNumbers(candidate, movie); int refSampleCount = candidate.getSamples().size(); long[] syncSamples = new long[refSyncSamples.length]; long sc = track.getSamples().size(); double stretch = (double) sc / refSampleCount; for (int i = 0; i < syncSamples.length; i++) { long start = (long) Math.ceil(stretch * (refSyncSamples[i] - 1)) + 1; syncSamples[i] = start; } getSampleNumbersCache.put(key, syncSamples); return syncSamples; } } throw new RuntimeException("There was absolutely no Track with sync samples. I can't work with that!"); } } SyncSampleIntersectFinderImpl(); SyncSampleIntersectFinderImpl(int minFragmentDurationSeconds); long[] sampleNumbers(Track track, Movie movie); static List<long[]> getSyncSamplesTimestamps(Movie movie, Track track); long[] getCommonIndices(long[] syncSamples, long[] syncSampleTimes, long timeScale, long[]... otherTracksTimes); } | @Test public void testFindSameFrameRate() throws IOException { Movie m = InTestMovieCreator.createMovieOnlyVideo( "/BBB_qpfile_10sec/BBB_fixedres_B_180x320_150.mp4", "/BBB_qpfile_10sec/BBB_fixedres_B_180x320_200.mp4" ); SyncSampleIntersectFinderImpl syncSampleIntersectFinder = new SyncSampleIntersectFinderImpl(); long[] fragmentStartSamplesRef = null; Assert.assertTrue(m.getTracks().size() > 1); for (Track track : m.getTracks()) { long[] fragmentStartSamples = syncSampleIntersectFinder.sampleNumbers(track, m); Assert.assertNotNull(fragmentStartSamples); if (fragmentStartSamplesRef == null) { fragmentStartSamplesRef = fragmentStartSamples; } else { Assert.assertArrayEquals(fragmentStartSamplesRef, fragmentStartSamples); } } }
@Test public void testFindDifferentFrameRates() throws IOException { Movie m = InTestMovieCreator.createMovieOnlyVideo( "/BBB_qpfile_10sec/BBB_fixedres_B_180x320_80.mp4", "/BBB_qpfile_10sec/BBB_fixedres_B_180x320_100.mp4", "/BBB_qpfile_10sec/BBB_fixedres_B_180x320_120.mp4", "/BBB_qpfile_10sec/BBB_fixedres_B_180x320_150.mp4", "/BBB_qpfile_10sec/BBB_fixedres_B_180x320_200.mp4" ); SyncSampleIntersectFinderImpl syncSampleIntersectFinder = new SyncSampleIntersectFinderImpl(); long[] fragmentStartSamplesRef = null; for (Track track : m.getTracks()) { long[] fragmentStartSamples = syncSampleIntersectFinder.sampleNumbers(track, m); Assert.assertNotNull(fragmentStartSamples); if (fragmentStartSamplesRef == null) { fragmentStartSamplesRef = fragmentStartSamples; } else { Assert.assertEquals(fragmentStartSamplesRef.length, fragmentStartSamples.length); } } } |
SyncSampleIntersectFinderImpl implements FragmentIntersectionFinder { public long[] getCommonIndices(long[] syncSamples, long[] syncSampleTimes, long timeScale, long[]... otherTracksTimes) { List<Long> nuSyncSamples = new LinkedList<Long>(); List<Long> nuSyncSampleTimes = new LinkedList<Long>(); for (int i = 0; i < syncSampleTimes.length; i++) { boolean foundInEveryRef = true; for (long[] times : otherTracksTimes) { foundInEveryRef &= (Arrays.binarySearch(times, syncSampleTimes[i]) >= 0); } if (foundInEveryRef) { nuSyncSamples.add(syncSamples[i]); nuSyncSampleTimes.add(syncSampleTimes[i]); } } if (nuSyncSamples.size() < (syncSamples.length * 0.25)) { String log = ""; log += String.format("%5d - Common: [", nuSyncSamples.size()); for (long l : nuSyncSamples) { log += (String.format("%10d,", l)); } log += ("]"); LOG.warning(log); log = ""; log += String.format("%5d - In : [", syncSamples.length); for (long l : syncSamples) { log += (String.format("%10d,", l)); } log += ("]"); LOG.warning(log); LOG.warning("There are less than 25% of common sync samples in the given track."); throw new RuntimeException("There are less than 25% of common sync samples in the given track."); } else if (nuSyncSamples.size() < (syncSamples.length * 0.5)) { LOG.fine("There are less than 50% of common sync samples in the given track. This is implausible but I'm ok to continue."); } else if (nuSyncSamples.size() < syncSamples.length) { LOG.finest("Common SyncSample positions vs. this tracks SyncSample positions: " + nuSyncSamples.size() + " vs. " + syncSamples.length); } List<Long> finalSampleList = new LinkedList<Long>(); if (minFragmentDurationSeconds > 0) { long lastSyncSampleTime = -1; Iterator<Long> nuSyncSamplesIterator = nuSyncSamples.iterator(); Iterator<Long> nuSyncSampleTimesIterator = nuSyncSampleTimes.iterator(); while (nuSyncSamplesIterator.hasNext() && nuSyncSampleTimesIterator.hasNext()) { long curSyncSample = nuSyncSamplesIterator.next(); long curSyncSampleTime = nuSyncSampleTimesIterator.next(); if (lastSyncSampleTime == -1 || (curSyncSampleTime - lastSyncSampleTime) / timeScale >= minFragmentDurationSeconds) { finalSampleList.add(curSyncSample); lastSyncSampleTime = curSyncSampleTime; } } } else { finalSampleList = nuSyncSamples; } long[] finalSampleArray = new long[finalSampleList.size()]; for (int i = 0; i < finalSampleArray.length; i++) { finalSampleArray[i] = finalSampleList.get(i); } return finalSampleArray; } SyncSampleIntersectFinderImpl(); SyncSampleIntersectFinderImpl(int minFragmentDurationSeconds); long[] sampleNumbers(Track track, Movie movie); static List<long[]> getSyncSamplesTimestamps(Movie movie, Track track); long[] getCommonIndices(long[] syncSamples, long[] syncSampleTimes, long timeScale, long[]... otherTracksTimes); } | @Test public void testGetIndicesToBeRemoved() { SyncSampleIntersectFinderImpl syncSampleIntersectFinder = new SyncSampleIntersectFinderImpl(); long[] a_sample = new long[]{20, 40, 48, 60, 80, 82}; long[] a_times = new long[]{10, 20, 24, 30, 40, 41}; long[] b_1 = new long[]{10, 20, 26, 30, 40}; long[] b_2 = new long[]{10, 20, 25, 30, 40}; long[] a_2 = syncSampleIntersectFinder.getCommonIndices(a_sample, a_times, 10, b_1, b_2); Assert.assertArrayEquals(new long[]{20, 40, 60, 80}, a_2); }
@Test public void testGetIndicesToBeRemovedMinTwoSecondsFragments() { SyncSampleIntersectFinderImpl syncSampleIntersectFinder = new SyncSampleIntersectFinderImpl(2); long[] a_sample = new long[]{20, 40, 48, 60, 80, 82, 90, 100}; long[] a_times = new long[]{10, 20, 24, 30, 60, 61, 80, 81}; long[] b_1 = new long[]{10, 20, 26, 30, 40, 80, 81, 100}; long[] b_2 = new long[]{10, 20, 25, 30, 40, 80, 90, 100}; long[] a_2 = syncSampleIntersectFinder.getCommonIndices(a_sample, a_times, 10, b_1, b_2); Assert.assertArrayEquals(new long[]{20, 60, 90}, a_2); } |
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); } | @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); } |
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); } | @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, "..")); } |
CroppedTrack extends AbstractTrack { public List<TimeToSampleBox.Entry> getDecodingTimeEntries() { return getDecodingTimeEntries(origTrack.getDecodingTimeEntries(), fromSample, toSample); } CroppedTrack(Track origTrack, long fromSample, long toSample); List<ByteBuffer> getSamples(); SampleDescriptionBox getSampleDescriptionBox(); List<TimeToSampleBox.Entry> getDecodingTimeEntries(); List<CompositionTimeToSample.Entry> getCompositionTimeEntries(); synchronized long[] getSyncSamples(); List<SampleDependencyTypeBox.Entry> getSampleDependencies(); TrackMetaData getTrackMetaData(); String getHandler(); Box getMediaHeaderBox(); SubSampleInformationBox getSubsampleInformationBox(); } | @Test public void testGetDecodingTimeEntries() throws Exception { LinkedList<TimeToSampleBox.Entry> e = new LinkedList<TimeToSampleBox.Entry>(); e.add(new TimeToSampleBox.Entry(2, 3)); e.add(new TimeToSampleBox.Entry(3, 4)); e.add(new TimeToSampleBox.Entry(3, 5)); e.add(new TimeToSampleBox.Entry(2, 6)); List<TimeToSampleBox.Entry> r = CroppedTrack.getDecodingTimeEntries(e, 0, 1); Assert.assertEquals(1, r.size()); Assert.assertEquals(1, r.get(0).getCount()); Assert.assertEquals(3, r.get(0).getDelta()); r = CroppedTrack.getDecodingTimeEntries(e, 0, 2); Assert.assertEquals(1, r.size()); Assert.assertEquals(2, r.get(0).getCount()); Assert.assertEquals(3, r.get(0).getDelta()); r = CroppedTrack.getDecodingTimeEntries(e, 1, 2); Assert.assertEquals(1, r.size()); Assert.assertEquals(1, r.get(0).getCount()); Assert.assertEquals(3, r.get(0).getDelta()); r = CroppedTrack.getDecodingTimeEntries(e, 1, 3); Assert.assertEquals(2, r.size()); Assert.assertEquals(1, r.get(0).getCount()); Assert.assertEquals(3, r.get(0).getDelta()); Assert.assertEquals(1, r.get(1).getCount()); Assert.assertEquals(4, r.get(1).getDelta()); r = CroppedTrack.getDecodingTimeEntries(e, 3, 4); Assert.assertEquals(1, r.size()); Assert.assertEquals(1, r.get(0).getCount()); Assert.assertEquals(4, r.get(0).getDelta()); r = CroppedTrack.getDecodingTimeEntries(e, 1, 6); Assert.assertEquals(3, r.size()); Assert.assertEquals(1, r.get(0).getCount()); Assert.assertEquals(3, r.get(0).getDelta()); Assert.assertEquals(3, r.get(1).getCount()); Assert.assertEquals(4, r.get(1).getDelta()); Assert.assertEquals(1, r.get(2).getCount()); Assert.assertEquals(5, r.get(2).getDelta()); r = CroppedTrack.getDecodingTimeEntries(e, 2, 6); Assert.assertEquals(2, r.size()); Assert.assertEquals(3, r.get(0).getCount()); Assert.assertEquals(4, r.get(0).getDelta()); Assert.assertEquals(1, r.get(1).getCount()); Assert.assertEquals(5, r.get(1).getDelta()); r = CroppedTrack.getDecodingTimeEntries(e, 2, 8); Assert.assertEquals(2, r.size()); Assert.assertEquals(3, r.get(0).getCount()); Assert.assertEquals(4, r.get(0).getDelta()); Assert.assertEquals(3, r.get(1).getCount()); Assert.assertEquals(5, r.get(1).getDelta()); } |
CroppedTrack extends AbstractTrack { public List<CompositionTimeToSample.Entry> getCompositionTimeEntries() { return getCompositionTimeEntries(origTrack.getCompositionTimeEntries(), fromSample, toSample); } CroppedTrack(Track origTrack, long fromSample, long toSample); List<ByteBuffer> getSamples(); SampleDescriptionBox getSampleDescriptionBox(); List<TimeToSampleBox.Entry> getDecodingTimeEntries(); List<CompositionTimeToSample.Entry> getCompositionTimeEntries(); synchronized long[] getSyncSamples(); List<SampleDependencyTypeBox.Entry> getSampleDependencies(); TrackMetaData getTrackMetaData(); String getHandler(); Box getMediaHeaderBox(); SubSampleInformationBox getSubsampleInformationBox(); } | @Test public void testGetCompositionTimes() throws Exception { LinkedList<CompositionTimeToSample.Entry> e = new LinkedList<CompositionTimeToSample.Entry>(); e.add(new CompositionTimeToSample.Entry(2, 3)); e.add(new CompositionTimeToSample.Entry(3, 4)); e.add(new CompositionTimeToSample.Entry(3, 5)); e.add(new CompositionTimeToSample.Entry(2, 6)); List<CompositionTimeToSample.Entry> r = CroppedTrack.getCompositionTimeEntries(e, 0, 1); Assert.assertEquals(1, r.size()); Assert.assertEquals(1, r.get(0).getCount()); Assert.assertEquals(3, r.get(0).getOffset()); r = CroppedTrack.getCompositionTimeEntries(e, 0, 2); Assert.assertEquals(1, r.size()); Assert.assertEquals(2, r.get(0).getCount()); Assert.assertEquals(3, r.get(0).getOffset()); r = CroppedTrack.getCompositionTimeEntries(e, 1, 2); Assert.assertEquals(1, r.size()); Assert.assertEquals(1, r.get(0).getCount()); Assert.assertEquals(3, r.get(0).getOffset()); r = CroppedTrack.getCompositionTimeEntries(e, 1, 3); Assert.assertEquals(2, r.size()); Assert.assertEquals(1, r.get(0).getCount()); Assert.assertEquals(3, r.get(0).getOffset()); Assert.assertEquals(1, r.get(1).getCount()); Assert.assertEquals(4, r.get(1).getOffset()); r = CroppedTrack.getCompositionTimeEntries(e, 3, 4); Assert.assertEquals(1, r.size()); Assert.assertEquals(1, r.get(0).getCount()); Assert.assertEquals(4, r.get(0).getOffset()); r = CroppedTrack.getCompositionTimeEntries(e, 1, 6); Assert.assertEquals(3, r.size()); Assert.assertEquals(1, r.get(0).getCount()); Assert.assertEquals(3, r.get(0).getOffset()); Assert.assertEquals(3, r.get(1).getCount()); Assert.assertEquals(4, r.get(1).getOffset()); Assert.assertEquals(1, r.get(2).getCount()); Assert.assertEquals(5, r.get(2).getOffset()); r = CroppedTrack.getCompositionTimeEntries(e, 2, 6); Assert.assertEquals(2, r.size()); Assert.assertEquals(3, r.get(0).getCount()); Assert.assertEquals(4, r.get(0).getOffset()); Assert.assertEquals(1, r.get(1).getCount()); Assert.assertEquals(5, r.get(1).getOffset()); r = CroppedTrack.getCompositionTimeEntries(e, 2, 8); Assert.assertEquals(2, r.size()); Assert.assertEquals(3, r.get(0).getCount()); Assert.assertEquals(4, r.get(0).getOffset()); Assert.assertEquals(3, r.get(1).getCount()); Assert.assertEquals(5, r.get(1).getOffset()); } |
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(); } | @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)); } |
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; } | @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()); } |
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); } | @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(); } |
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); } | @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); } |
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); } | @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); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.