method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public int update(String statement, Object[] args, FieldType[] argfieldTypes) throws SQLException { if (proxy == null) { return 0; } else { return proxy.update(statement, args, argfieldTypes); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testUpdate() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); String statement = "insert bar"; int result = 13212321; expect(conn.update(statement, null, null)).andReturn(result); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(result, proxy.update(statement, null, null)); proxy.close(); verify(conn); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public int delete(String statement, Object[] args, FieldType[] argfieldTypes) throws SQLException { if (proxy == null) { return 0; } else { return proxy.delete(statement, args, argfieldTypes); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testDelete() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); String statement = "insert bar"; int result = 13872321; expect(conn.delete(statement, null, null)).andReturn(result); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(result, proxy.delete(statement, null, null)); proxy.close(); verify(conn); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public <T> Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes, GenericRowMapper<T> rowMapper, ObjectCache objectCache) throws SQLException { if (proxy == null) { return null; } else { return proxy.queryForOne(statement, args, argfieldTypes, rowMapper, objectCache); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testQueryForOne() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); String statement = "insert bar"; Object result = new Object(); expect(conn.queryForOne(statement, null, null, null, null)).andReturn(result); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(result, proxy.queryForOne(statement, null, null, null, null)); proxy.close(); verify(conn); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public void close() throws IOException { if (proxy != null) { proxy.close(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testClose() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.close(); verify(conn); }
@Test public void testCloseNull() throws Exception { new DatabaseConnectionProxy(null).close(); } |
### Question:
InitStat { public void recordInit(long initTime) { if (initTime >= 0) { initCount.increment(); totalInitTime.add(initTime); } } private InitStat(); static InitStat create(); void recordInit(long initTime); long getInitCount(); long getTotalInitTime(); }### Answer:
@Test public void testRecordInit() throws Exception { InitStat stat = InitStat.create(); long a = 1000; long b = 500; stat.recordInit(a); assertThat(stat.getInitCount(), equalTo(1L)); assertThat(stat.getTotalInitTime(), equalTo(a)); stat.recordInit(b); assertThat(stat.getInitCount(), equalTo(2L)); assertThat(stat.getTotalInitTime(), equalTo(a + b)); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public void closeQuietly() { if (proxy != null) { proxy.closeQuietly(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testCloseQuietly() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); conn.closeQuietly(); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.closeQuietly(); proxy.close(); verify(conn); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isClosed() throws SQLException { if (proxy == null) { return true; } else { return proxy.isClosed(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testIsClosed() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean closed = true; expect(conn.isClosed()).andReturn(closed); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(closed, proxy.isClosed()); proxy.close(); verify(conn); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isTableExists(String tableName) throws SQLException { if (proxy == null) { return false; } else { return proxy.isTableExists(tableName); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testIsTableExists() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean tableExists = true; String tableName = "fjewfjwef"; expect(conn.isTableExists(tableName)).andReturn(tableExists); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(tableExists, proxy.isTableExists(tableName)); proxy.close(); verify(conn); } |
### Question:
SelectIterator implements CloseableIterator<T> { public boolean hasNextThrow() throws SQLException { if (closed) { return false; } if (alreadyMoved) { return true; } boolean result; if (first) { first = false; result = results.first(); } else { result = results.next(); } if (!result) { IOUtils.closeThrowSqlException(this, "iterator"); } alreadyMoved = true; return result; } SelectIterator(Class<?> dataClass, Dao<T, ID> classDao, GenericRowMapper<T> rowMapper,
ConnectionSource connectionSource, DatabaseConnection connection, CompiledStatement compiledStmt,
String statement, ObjectCache objectCache); boolean hasNextThrow(); @Override boolean hasNext(); @Override T first(); @Override T previous(); @Override T current(); @Override T nextThrow(); @Override T next(); @Override T moveRelative(int offset); void removeThrow(); @Override void remove(); @Override void close(); @Override void closeQuietly(); @Override DatabaseResults getRawResults(); @Override void moveToNext(); }### Answer:
@Test(expected = IllegalStateException.class) public void testHasNextThrow() throws Exception { ConnectionSource cs = createMock(ConnectionSource.class); cs.releaseConnection(null); CompiledStatement stmt = createMock(CompiledStatement.class); DatabaseResults results = createMock(DatabaseResults.class); expect(stmt.runQuery(null)).andReturn(results); expect(results.first()).andThrow(new SQLException("some database problem")); stmt.close(); replay(stmt, results, cs); SelectIterator<Foo, Integer> iterator = new SelectIterator<Foo, Integer>(Foo.class, null, null, cs, null, stmt, "statement", null); try { iterator.hasNext(); } finally { iterator.close(); } } |
### Question:
SelectIterator implements CloseableIterator<T> { @Override public T nextThrow() throws SQLException { if (closed) { return null; } if (!alreadyMoved) { boolean hasResult; if (first) { first = false; hasResult = results.first(); } else { hasResult = results.next(); } if (!hasResult) { first = false; return null; } } first = false; return getCurrent(); } SelectIterator(Class<?> dataClass, Dao<T, ID> classDao, GenericRowMapper<T> rowMapper,
ConnectionSource connectionSource, DatabaseConnection connection, CompiledStatement compiledStmt,
String statement, ObjectCache objectCache); boolean hasNextThrow(); @Override boolean hasNext(); @Override T first(); @Override T previous(); @Override T current(); @Override T nextThrow(); @Override T next(); @Override T moveRelative(int offset); void removeThrow(); @Override void remove(); @Override void close(); @Override void closeQuietly(); @Override DatabaseResults getRawResults(); @Override void moveToNext(); }### Answer:
@Test(expected = IllegalStateException.class) public void testNextThrow() throws Exception { ConnectionSource cs = createMock(ConnectionSource.class); cs.releaseConnection(null); CompiledStatement stmt = createMock(CompiledStatement.class); DatabaseResults results = createMock(DatabaseResults.class); expect(stmt.runQuery(null)).andReturn(results); expect(results.first()).andThrow(new SQLException("some result problem")); @SuppressWarnings("unchecked") GenericRowMapper<Foo> mapper = (GenericRowMapper<Foo>) createMock(GenericRowMapper.class); stmt.close(); replay(stmt, mapper, cs, results); SelectIterator<Foo, Integer> iterator = new SelectIterator<Foo, Integer>(Foo.class, null, mapper, cs, null, stmt, "statement", null); try { iterator.hasNext(); } finally { iterator.close(); } verify(stmt, mapper, cs, results); } |
### Question:
SelectIterator implements CloseableIterator<T> { public void removeThrow() throws SQLException { if (last == null) { throw new IllegalStateException("No last " + dataClass + " object to remove. Must be called after a call to next."); } if (classDao == null) { throw new IllegalStateException("Cannot remove " + dataClass + " object because classDao not initialized"); } try { classDao.delete(last); } finally { last = null; } } SelectIterator(Class<?> dataClass, Dao<T, ID> classDao, GenericRowMapper<T> rowMapper,
ConnectionSource connectionSource, DatabaseConnection connection, CompiledStatement compiledStmt,
String statement, ObjectCache objectCache); boolean hasNextThrow(); @Override boolean hasNext(); @Override T first(); @Override T previous(); @Override T current(); @Override T nextThrow(); @Override T next(); @Override T moveRelative(int offset); void removeThrow(); @Override void remove(); @Override void close(); @Override void closeQuietly(); @Override DatabaseResults getRawResults(); @Override void moveToNext(); }### Answer:
@Test(expected = IllegalStateException.class) public void testRemoveThrow() throws Exception { ConnectionSource cs = createMock(ConnectionSource.class); cs.releaseConnection(null); CompiledStatement stmt = createMock(CompiledStatement.class); DatabaseResults results = createMock(DatabaseResults.class); expect(results.first()).andReturn(true); expect(stmt.runQuery(null)).andReturn(results); @SuppressWarnings("unchecked") GenericRowMapper<Foo> mapper = (GenericRowMapper<Foo>) createMock(GenericRowMapper.class); Foo foo = new Foo(); expect(mapper.mapRow(results)).andReturn(foo); @SuppressWarnings("unchecked") Dao<Foo, Integer> dao = (Dao<Foo, Integer>) createMock(Dao.class); expect(dao.delete(foo)).andThrow(new SQLException("some dao problem")); stmt.close(); replay(stmt, dao, results, mapper, cs); SelectIterator<Foo, Integer> iterator = new SelectIterator<Foo, Integer>(Foo.class, dao, mapper, cs, null, stmt, "statement", null); try { iterator.hasNext(); iterator.next(); iterator.remove(); } finally { iterator.close(); } } |
### Question:
QueryBuilder extends StatementBuilder<T, ID> { @Override protected String getTableName() { return (alias == null ? tableName : alias); } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }### Answer:
@Test public void testSelectAll() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); }
@Test public void testWhere() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); Where<Foo, Integer> where = qb.where(); String val = "1"; where.eq(Foo.ID_COLUMN_NAME, val); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(" WHERE "); databaseType.appendEscapedEntityName(sb, Foo.ID_COLUMN_NAME); sb.append(" = ").append(val).append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); }
@Test public void testWhereSelectArg() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); Where<Foo, Integer> where = qb.where(); SelectArg val = new SelectArg(); where.eq(Foo.ID_COLUMN_NAME, val); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(" WHERE "); databaseType.appendEscapedEntityName(sb, Foo.ID_COLUMN_NAME); sb.append(" = ? "); assertEquals(sb.toString(), qb.prepareStatementString()); qb.setWhere(where); assertEquals(sb.toString(), qb.prepareStatementString()); } |
### Question:
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> selectColumns(String... columns) { for (String column : columns) { addSelectColumnToList(column); } return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testAddBadColumn() { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); qb.selectColumns("unknown-column"); } |
### Question:
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> groupBy(String columnName) { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new IllegalArgumentException("Can't groupBy foreign colletion field: " + columnName); } addGroupBy(ColumnNameOrRawSql.withColumnName(columnName)); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }### Answer:
@Test public void testGroupBy() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); String field1 = Foo.VAL_COLUMN_NAME; qb.groupBy(field1); String field2 = Foo.ID_COLUMN_NAME; qb.groupBy(field2); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(" GROUP BY "); databaseType.appendEscapedEntityName(sb, field1); sb.append(','); databaseType.appendEscapedEntityName(sb, field2); sb.append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); } |
### Question:
Elements extends ArrayList<Element> { public boolean hasAttr(String attributeKey) { for (Element element : this) { if (element.hasAttr(attributeKey)) return true; } return false; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void hasAttr() { Document doc = Jsoup.parse("<p title=foo><p title=bar><p class=foo><p class=bar>"); Elements ps = doc.select("p"); assertTrue(ps.hasAttr("class")); assertFalse(ps.hasAttr("style")); } |
### Question:
MangoDaoScanner implements BeanFactoryPostProcessor { public void setPackages(List<String> packages) { for (String p : packages) { for (String daoEnd : DAO_ENDS) { String locationPattern = "classpath*:" + p.replaceAll("\\.", "/") + "*" + daoEnd + ".class"; logger.info("trnas package[" + p + "] to locationPattern[" + locationPattern + "]"); locationPatterns.add(locationPattern); } } } @Override void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory); void setPackages(List<String> packages); void setFactoryBeanClass(Class<?> factoryBeanClass); }### Answer:
@Test public void testSetPackages() throws Exception { MangoDaoScanner mc = new MangoDaoScanner(); List<String> packages = Lists.newArrayList("org.jfaster.mango", "", "org.jfaster"); mc.setPackages(packages); assertThat(mc.locationPatterns.get(0), is("classpath*:org/jfaster/mango*Dao.class")); assertThat(mc.locationPatterns.get(1), is("classpath*:org/jfaster/mango*DAO.class")); assertThat(mc.locationPatterns.get(2), is("classpath*:*Dao.class")); assertThat(mc.locationPatterns.get(3), is("classpath*:*DAO.class")); assertThat(mc.locationPatterns.get(4), is("classpath*:org/jfaster*Dao.class")); assertThat(mc.locationPatterns.get(5), is("classpath*:org/jfaster*DAO.class")); } |
### Question:
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> orderBy(String columnName, boolean ascending) { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new IllegalArgumentException("Can't orderBy foreign colletion field: " + columnName); } addOrderBy(new OrderBy(columnName, ascending)); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }### Answer:
@Test public void testOrderBy() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); String field1 = Foo.VAL_COLUMN_NAME; qb.orderBy(field1, true); String field2 = Foo.ID_COLUMN_NAME; qb.orderBy(field2, true); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(" ORDER BY "); databaseType.appendEscapedEntityName(sb, field1); sb.append(','); databaseType.appendEscapedEntityName(sb, field2); sb.append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); } |
### Question:
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> distinct() { distinct = true; selectIdColumn = false; return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }### Answer:
@Test public void testDistinct() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); qb.distinct(); StringBuilder sb = new StringBuilder(); sb.append("SELECT DISTINCT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); } |
### Question:
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> limit(Long maxRows) { limit = maxRows; return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }### Answer:
@Test public void testLimit() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); long limit = 103; qb.limit(limit); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(" LIMIT ").append(limit).append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); } |
### Question:
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> offset(Long startRow) throws SQLException { if (databaseType.isOffsetSqlSupported()) { offset = startRow; return this; } else { throw new SQLException("Offset is not supported by this database"); } } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }### Answer:
@Test public void testOffset() throws Exception { QueryBuilder<Foo, Integer> qb = new QueryBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); long offset = 1; long limit = 2; qb.offset(offset); qb.limit(limit); StringBuilder sb = new StringBuilder(); sb.append("SELECT * FROM "); databaseType.appendEscapedEntityName(sb, baseFooTableInfo.getTableName()); sb.append(" LIMIT ").append(offset).append(',').append(limit).append(' '); assertEquals(sb.toString(), qb.prepareStatementString()); } |
### Question:
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> orderByRaw(String rawSql) { addOrderBy(new OrderBy(rawSql, (ArgumentHolder[]) null)); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }### Answer:
@Test public void testOrderByRaw() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); foo1.val = 1; foo1.equal = 10; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); foo2.val = 5; foo2.equal = 7; assertEquals(1, dao.create(foo2)); List<Foo> results = dao.queryBuilder() .orderByRaw("(" + Foo.VAL_COLUMN_NAME + "+" + Foo.EQUAL_COLUMN_NAME + ") DESC") .query(); assertEquals(2, results.size()); assertEquals(foo2.id, results.get(0).id); assertEquals(foo1.id, results.get(1).id); } |
### Question:
QueryBuilder extends StatementBuilder<T, ID> { public QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder) throws SQLException { addJoinInfo(JoinType.LEFT, null, null, joinedQueryBuilder, JoinWhereOperation.AND); return this; } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }### Answer:
@Test public void testLeftJoin() throws Exception { Dao<Bar, Integer> barDao = createDao(Bar.class, true); Dao<Baz, Integer> bazDao = createDao(Baz.class, true); Bar bar1 = new Bar(); bar1.val = 2234; assertEquals(1, barDao.create(bar1)); Bar bar2 = new Bar(); bar2.val = 324322234; assertEquals(1, barDao.create(bar2)); Baz baz1 = new Baz(); baz1.bar = bar1; assertEquals(1, bazDao.create(baz1)); Baz baz2 = new Baz(); baz2.bar = bar2; assertEquals(1, bazDao.create(baz2)); Baz baz3 = new Baz(); assertEquals(1, bazDao.create(baz3)); QueryBuilder<Bar, Integer> barQb = barDao.queryBuilder(); List<Baz> results = bazDao.queryBuilder().query(); assertEquals(3, results.size()); results = bazDao.queryBuilder().join(barQb).query(); assertEquals(2, results.size()); results = bazDao.queryBuilder().leftJoin(barQb).query(); assertEquals(3, results.size()); results = bazDao.queryBuilder().join(barQb, JoinType.LEFT, JoinWhereOperation.AND).query(); assertEquals(3, results.size()); } |
### Question:
QueryBuilder extends StatementBuilder<T, ID> { public long countOf() throws SQLException { String countOfQuerySave = this.countOfQuery; try { setCountOf(true); return dao.countOf(prepare()); } finally { setCountOf(countOfQuerySave); } } QueryBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedQuery<T> prepare(); QueryBuilder<T, ID> selectColumns(String... columns); QueryBuilder<T, ID> selectColumns(Iterable<String> columns); QueryBuilder<T, ID> selectRaw(String... columns); QueryBuilder<T, ID> groupBy(String columnName); QueryBuilder<T, ID> groupByRaw(String rawSql); QueryBuilder<T, ID> orderBy(String columnName, boolean ascending); QueryBuilder<T, ID> orderByRaw(String rawSql); QueryBuilder<T, ID> orderByRaw(String rawSql, ArgumentHolder... args); QueryBuilder<T, ID> distinct(); QueryBuilder<T, ID> limit(Long maxRows); QueryBuilder<T, ID> offset(Long startRow); QueryBuilder<T, ID> setCountOf(boolean countOf); QueryBuilder<T, ID> setCountOf(String countOfQuery); QueryBuilder<T, ID> having(String having); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); QueryBuilder<T, ID> joinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoin(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> leftJoinOr(QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder); QueryBuilder<T, ID> join(String localColumnName, String joinedColumnName,
QueryBuilder<?, ?> joinedQueryBuilder, JoinType type, JoinWhereOperation operation); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); CloseableIterator<T> iterator(); long countOf(); long countOf(String countOfQuery); QueryBuilder<T, ID> setAlias(String alias); @Override void reset(); }### Answer:
@Test public void testCountOf() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); QueryBuilder<Foo, Integer> qb = dao.queryBuilder(); assertEquals(0, qb.countOf()); Foo foo1 = new Foo(); int val = 123213; foo1.val = val; assertEquals(1, dao.create(foo1)); assertEquals(1, qb.countOf()); Foo foo2 = new Foo(); foo2.val = val; assertEquals(1, dao.create(foo2)); assertEquals(2, qb.countOf()); String distinct = "DISTINCT(" + Foo.VAL_COLUMN_NAME + ")"; assertEquals(1, qb.countOf(distinct)); qb.setCountOf(distinct); assertEquals(1, dao.countOf(qb.prepare())); distinct = "DISTINCT(" + Foo.ID_COLUMN_NAME + ")"; assertEquals(2, qb.countOf(distinct)); qb.setCountOf(distinct); assertEquals(2, dao.countOf(qb.prepare())); } |
### Question:
Elements extends ArrayList<Element> { public String attr(String attributeKey) { for (Element element : this) { if (element.hasAttr(attributeKey)) return element.attr(attributeKey); } return ""; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void attr() { Document doc = Jsoup.parse("<p title=foo><p title=bar><p class=foo><p class=bar>"); String classVal = doc.select("p").attr("class"); assertEquals("foo", classVal); } |
### Question:
In extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList) throws SQLException { sb.append('('); boolean first = true; for (Object value : objects) { if (value == null) { throw new IllegalArgumentException("one of the IN values for '" + columnName + "' is null"); } if (first) { first = false; } else { sb.append(','); } super.appendArgOrValue(databaseType, fieldType, sb, columnArgList, value); } sb.append(") "); } In(String columnName, FieldType fieldType, Iterable<?> objects, boolean in); In(String columnName, FieldType fieldType, Object[] objects, boolean in); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> columnArgList); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testAppendValueNull() throws Exception { List<Object> objList = new ArrayList<Object>(); objList.add(null); In in = new In("foo", numberFieldType, objList, true); in.appendValue(null, new StringBuilder(), null); }
@Test public void testAppendValue() throws Exception { List<Object> objList = new ArrayList<Object>(); Random random = new Random(); int numArgs = 100; for (int i = 0; i < numArgs; i++) { objList.add((Integer) random.nextInt()); } In in = new In("foo", numberFieldType, objList, true); StringBuilder sb = new StringBuilder(); in.appendValue(null, sb, new ArrayList<ArgumentHolder>()); String[] args = sb.toString().split(","); assertEquals("(" + objList.get(0) + " ", args[0]); for (int i = 1; i < numArgs - 1; i++) { assertEquals(objList.get(i) + " ", args[i]); } assertEquals(objList.get(numArgs - 1) + " ) ", args[numArgs - 1]); } |
### Question:
Between extends BaseComparison { @Override public void appendOperation(StringBuilder sb) { sb.append("BETWEEN "); } Between(String columnName, FieldType fieldType, Object low, Object high); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); }### Answer:
@Test public void testAppendOperation() throws Exception { int low = 10; int high = 20; Between btw = new Between(COLUMN_NAME, numberFieldType, low, high); StringBuilder sb = new StringBuilder(); btw.appendOperation(sb); assertTrue(sb.toString().contains("BETWEEN")); sb.setLength(0); btw.appendValue(null, sb, new ArrayList<ArgumentHolder>()); assertEquals(low + " AND " + high + " ", sb.toString()); } |
### Question:
Between extends BaseComparison { @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) throws SQLException { if (low == null) { throw new IllegalArgumentException("BETWEEN low value for '" + columnName + "' is null"); } if (high == null) { throw new IllegalArgumentException("BETWEEN high value for '" + columnName + "' is null"); } appendArgOrValue(databaseType, fieldType, sb, argList, low); sb.append("AND "); appendArgOrValue(databaseType, fieldType, sb, argList, high); } Between(String columnName, FieldType fieldType, Object low, Object high); @Override void appendOperation(StringBuilder sb); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testAppendValueLowNull() throws Exception { new Between(COLUMN_NAME, numberFieldType, null, 20L).appendValue(null, new StringBuilder(), new ArrayList<ArgumentHolder>()); }
@Test(expected = IllegalArgumentException.class) public void testAppendValueHighNull() throws Exception { new Between(COLUMN_NAME, numberFieldType, 10L, null).appendValue(null, new StringBuilder(), new ArrayList<ArgumentHolder>()); } |
### Question:
BaseComparison implements Comparison { protected void appendArgOrValue(DatabaseType databaseType, FieldType fieldType, StringBuilder sb, List<ArgumentHolder> argList, Object argOrValue) throws SQLException { boolean appendSpace = true; if (argOrValue == null) { throw new SQLException("argument for '" + fieldType.getFieldName() + "' is null"); } else if (argOrValue instanceof ArgumentHolder) { sb.append('?'); ArgumentHolder argHolder = (ArgumentHolder) argOrValue; argHolder.setMetaInfo(columnName, fieldType); argList.add(argHolder); } else if (argOrValue instanceof ColumnArg) { ColumnArg columnArg = (ColumnArg) argOrValue; String tableName = columnArg.getTableName(); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, columnArg.getColumnName()); } else if (fieldType.isArgumentHolderRequired()) { sb.append('?'); ArgumentHolder argHolder = new SelectArg(); argHolder.setMetaInfo(columnName, fieldType); argHolder.setValue(argOrValue); argList.add(argHolder); } else if (fieldType.isForeign() && fieldType.getType().isAssignableFrom(argOrValue.getClass())) { FieldType idFieldType = fieldType.getForeignIdField(); appendArgOrValue(databaseType, idFieldType, sb, argList, idFieldType.extractJavaFieldValue(argOrValue)); appendSpace = false; } else if (fieldType.isEscapedValue()) { databaseType.appendEscapedWord(sb, fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString()); } else if (fieldType.isForeign()) { String value = fieldType.convertJavaFieldToSqlArgValue(argOrValue).toString(); if (value.length() > 0) { if (NUMBER_CHARACTERS.indexOf(value.charAt(0)) < 0) { throw new SQLException("Foreign field " + fieldType + " does not seem to be producing a numerical value '" + value + "'. Maybe you are passing the wrong object to comparison: " + this); } } sb.append(value); } else { sb.append(fieldType.convertJavaFieldToSqlArgValue(argOrValue)); } if (appendSpace) { sb.append(' '); } } protected BaseComparison(String columnName, FieldType fieldType, Object value, boolean isComparison); @Override abstract void appendOperation(StringBuilder sb); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> argList); @Override String getColumnName(); @Override void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList); @Override String toString(); }### Answer:
@Test(expected = SQLException.class) public void testAppendArgOrValueNull() throws Exception { cmpInt.appendArgOrValue(null, numberFieldType, new StringBuilder(), new ArrayList<ArgumentHolder>(), null); }
@Test public void testAppendArgOrValueString() throws SQLException { String value = "23wbdqwbdq13"; StringBuilder sb = new StringBuilder(); DatabaseType databaseType = createMock(DatabaseType.class); databaseType.appendEscapedWord(sb, value); replay(databaseType); cmpString.appendArgOrValue(databaseType, stringFieldType, sb, new ArrayList<ArgumentHolder>(), value); verify(databaseType); }
@Test(expected = SQLException.class) public void testForeignIdNull() throws Exception { StringBuilder sb = new StringBuilder(); Field field = ForeignNull.class.getDeclaredField("foreign"); FieldType fieldType = FieldType.createFieldType(connectionSource, "BaseFoo", field, ForeignNull.class); fieldType.configDaoInformation(connectionSource, ForeignNull.class); ForeignNullForeign foo = new ForeignNullForeign(); foo.id = null; cmpForeign.appendArgOrValue(databaseType, fieldType, sb, new ArrayList<ArgumentHolder>(), foo); } |
### Question:
Not implements Clause, NeedsFutureClause { @Override public void setMissingClause(Clause clause) { if (this.comparison != null) { throw new IllegalArgumentException("NOT operation already has a comparison set"); } else if (clause instanceof Comparison) { this.comparison = (Comparison) clause; } else if (clause instanceof Exists) { this.exists = (Exists) clause; } else { throw new IllegalArgumentException("NOT operation can only work with comparison SQL clauses, not " + clause); } } Not(); Not(Clause clause); @Override void setMissingClause(Clause clause); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb,
List<ArgumentHolder> selectArgList); @Override String toString(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void test() { Not not = new Not(); Clause clause = new Comparison() { @Override public void appendOperation(StringBuilder sb) { } @Override public void appendValue(DatabaseType databaseType, StringBuilder sb, List<ArgumentHolder> argList) { } @Override public String getColumnName() { return null; } @Override public void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> argList) { } }; not.setMissingClause(clause); not.setMissingClause(clause); }
@Test(expected = IllegalArgumentException.class) public void testBaseNotClause() { Not not = new Not(); not.setMissingClause(new ManyClause((Clause) null, "AND")); } |
### Question:
Not implements Clause, NeedsFutureClause { @Override public void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb, List<ArgumentHolder> selectArgList) throws SQLException { if (comparison == null && exists == null) { throw new IllegalStateException("Clause has not been set in NOT operation"); } if (comparison == null) { sb.append("(NOT "); exists.appendSql(databaseType, tableName, sb, selectArgList); } else { sb.append("(NOT "); if (tableName != null) { databaseType.appendEscapedEntityName(sb, tableName); sb.append('.'); } databaseType.appendEscapedEntityName(sb, comparison.getColumnName()); sb.append(' '); comparison.appendOperation(sb); comparison.appendValue(databaseType, sb, selectArgList); } sb.append(") "); } Not(); Not(Clause clause); @Override void setMissingClause(Clause clause); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb,
List<ArgumentHolder> selectArgList); @Override String toString(); }### Answer:
@Test(expected = IllegalStateException.class) public void testNoClause() throws Exception { Not not = new Not(); not.appendSql(databaseType, null, new StringBuilder(), new ArrayList<ArgumentHolder>()); } |
### Question:
Elements extends ArrayList<Element> { public String text() { StringBuilder sb = new StringBuilder(); for (Element element : this) { if (sb.length() != 0) sb.append(" "); sb.append(element.text()); } return sb.toString(); } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void text() { String h = "<div><p>Hello<p>there<p>world</div>"; Document doc = Jsoup.parse(h); assertEquals("Hello there world", doc.select("div > *").text()); }
@Test public void classWithHyphen() { Document doc = Jsoup.parse("<p class='tab-nav'>Check</p>"); Elements els = doc.getElementsByClass("tab-nav"); assertEquals(1, els.size()); assertEquals("Check", els.text()); } |
### Question:
Not implements Clause, NeedsFutureClause { @Override public String toString() { if (comparison == null) { return "NOT without comparison"; } else { return "NOT comparison " + comparison; } } Not(); Not(Clause clause); @Override void setMissingClause(Clause clause); @Override void appendSql(DatabaseType databaseType, String tableName, StringBuilder sb,
List<ArgumentHolder> selectArgList); @Override String toString(); }### Answer:
@Test public void testToString() throws Exception { String name = "foo"; String value = "bar"; SimpleComparison eq = new SimpleComparison(name, numberFieldType, value, SimpleComparison.EQUAL_TO_OPERATION); Not not = new Not(); assertTrue(not.toString().contains("NOT without comparison")); not.setMissingClause(eq); assertTrue(not.toString().contains("NOT comparison")); assertTrue(not.toString().contains(eq.toString())); } |
### Question:
RawResultsImpl implements GenericRawResults<T> { @Override public List<T> getResults() throws SQLException { List<T> results = new ArrayList<T>(); try { while (iterator.hasNext()) { results.add(iterator.next()); } return results; } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } RawResultsImpl(ConnectionSource connectionSource, DatabaseConnection connection, String query,
Class<?> clazz, CompiledStatement compiledStmt, GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override int getNumberColumns(); @Override String[] getColumnNames(); @Override List<T> getResults(); @Override T getFirstResult(); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override void close(); }### Answer:
@Test public void testQueryRawColumns() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); foo1.val = 1; foo1.equal = 10; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); foo2.val = 10; foo2.equal = 5; assertEquals(1, dao.create(foo2)); QueryBuilder<Foo, Integer> qb = dao.queryBuilder(); qb.selectRaw("COUNT(*)"); GenericRawResults<String[]> rawResults = dao.queryRaw(qb.prepareStatementString()); List<String[]> results = rawResults.getResults(); assertEquals(1, results.size()); assertEquals("2", results.get(0)[0]); qb = dao.queryBuilder(); qb.selectRaw("MIN(val)", "MAX(val)"); rawResults = dao.queryRaw(qb.prepareStatementString()); results = rawResults.getResults(); assertEquals(1, results.size()); String[] result = results.get(0); assertEquals(2, result.length); assertEquals(Integer.toString(foo1.val), result[0]); assertEquals(Integer.toString(foo2.val), result[1]); }
@Test public void testHaving() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo = new Foo(); int val1 = 243342; foo.val = val1; assertEquals(1, dao.create(foo)); foo = new Foo(); foo.val = val1; assertEquals(1, dao.create(foo)); foo = new Foo(); int val2 = 6543; foo.val = val2; assertEquals(1, dao.create(foo)); QueryBuilder<Foo, Integer> qb = dao.queryBuilder(); qb.selectColumns(Foo.VAL_COLUMN_NAME); qb.groupBy(Foo.VAL_COLUMN_NAME); qb.having("COUNT(VAL) > 1"); GenericRawResults<String[]> results = dao.queryRaw(qb.prepareStatementString()); List<String[]> list = results.getResults(); assertEquals(1, list.size()); assertEquals(String.valueOf(val1), list.get(0)[0]); qb.having("COUNT(VAL) > 2"); results = dao.queryRaw(qb.prepareStatementString()); list = results.getResults(); assertEquals(0, list.size()); } |
### Question:
RawResultsImpl implements GenericRawResults<T> { @Override public T getFirstResult() throws SQLException { try { if (iterator.hasNextThrow()) { return iterator.nextThrow(); } else { return null; } } finally { IOUtils.closeThrowSqlException(this, "raw results iterator"); } } RawResultsImpl(ConnectionSource connectionSource, DatabaseConnection connection, String query,
Class<?> clazz, CompiledStatement compiledStmt, GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override int getNumberColumns(); @Override String[] getColumnNames(); @Override List<T> getResults(); @Override T getFirstResult(); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override void close(); }### Answer:
@Test public void testGetFirstResult() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); foo1.val = 342; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); foo2.val = 9045342; assertEquals(1, dao.create(foo2)); QueryBuilder<Foo, Integer> qb = dao.queryBuilder(); qb.selectRaw("MAX(" + Foo.VAL_COLUMN_NAME + ")"); GenericRawResults<String[]> results = dao.queryRaw(qb.prepareStatementString()); String[] result = results.getFirstResult(); int max = Integer.parseInt(result[0]); if (foo1.val > foo2.val) { assertEquals(foo1.val, max); } else { assertEquals(foo2.val, max); } } |
### Question:
MappedDeleteCollection extends BaseMappedStatement<T, ID> { public static <T, ID> int deleteObjects(DatabaseType databaseType, TableInfo<T, ID> tableInfo, DatabaseConnection databaseConnection, Collection<T> datas, ObjectCache objectCache) throws SQLException { MappedDeleteCollection<T, ID> deleteCollection = MappedDeleteCollection.build(databaseType, tableInfo, datas.size()); Object[] fieldObjects = new Object[datas.size()]; FieldType idField = tableInfo.getIdField(); int objC = 0; for (T data : datas) { fieldObjects[objC] = idField.extractJavaFieldToSqlArgValue(data); objC++; } return updateRows(databaseConnection, tableInfo.getDataClass(), deleteCollection, fieldObjects, objectCache); } private MappedDeleteCollection(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); static int deleteObjects(DatabaseType databaseType, TableInfo<T, ID> tableInfo,
DatabaseConnection databaseConnection, Collection<T> datas, ObjectCache objectCache); static int deleteIds(DatabaseType databaseType, TableInfo<T, ID> tableInfo,
DatabaseConnection databaseConnection, Collection<ID> ids, ObjectCache objectCache); }### Answer:
@Test(expected = SQLException.class) public void testNoIdBuildDelete() throws Exception { DatabaseConnection databaseConnection = createMock(DatabaseConnection.class); ConnectionSource connectionSource = createMock(ConnectionSource.class); expect(connectionSource.getDatabaseType()).andReturn(databaseType).anyTimes(); replay(connectionSource); MappedDeleteCollection.deleteObjects(databaseType, new TableInfo<NoId, Void>(connectionSource, null, NoId.class), databaseConnection, new ArrayList<NoId>(), null); } |
### Question:
Elements extends ArrayList<Element> { public boolean hasText() { for (Element element: this) { if (element.hasText()) return true; } return false; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void hasText() { Document doc = Jsoup.parse("<div><p>Hello</p></div><div><p></p></div>"); Elements divs = doc.select("div"); assertTrue(divs.hasText()); assertFalse(doc.select("div + div").hasText()); } |
### Question:
MappedCreate extends BaseMappedStatement<T, ID> { public static <T, ID> MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) { StringBuilder sb = new StringBuilder(128); appendTableName(databaseType, sb, "INSERT INTO ", tableInfo.getTableName()); int argFieldC = 0; int versionFieldTypeIndex = -1; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (isFieldCreatable(databaseType, fieldType)) { if (fieldType.isVersion()) { versionFieldTypeIndex = argFieldC; } argFieldC++; } } FieldType[] argFieldTypes = new FieldType[argFieldC]; if (argFieldC == 0) { databaseType.appendInsertNoColumns(sb); } else { argFieldC = 0; boolean first = true; sb.append('('); for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldCreatable(databaseType, fieldType)) { continue; } if (first) { first = false; } else { sb.append(','); } appendFieldColumnName(databaseType, sb, fieldType, null); argFieldTypes[argFieldC++] = fieldType; } sb.append(") VALUES ("); first = true; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldCreatable(databaseType, fieldType)) { continue; } if (first) { first = false; } else { sb.append(','); } sb.append('?'); } sb.append(')'); } FieldType idField = tableInfo.getIdField(); String queryNext = buildQueryNextSequence(databaseType, idField); return new MappedCreate<T, ID>(tableInfo, sb.toString(), argFieldTypes, queryNext, versionFieldTypeIndex); } private MappedCreate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
String queryNextSequenceStmt, int versionFieldTypeIndex); int insert(DatabaseType databaseType, DatabaseConnection databaseConnection, T data, ObjectCache objectCache); static MappedCreate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); }### Answer:
@Test public void testNoCreateSequence() throws Exception { MappedCreate.build(databaseType, new TableInfo<GeneratedId, Integer>(connectionSource, null, GeneratedId.class)); } |
### Question:
MappedUpdateId extends BaseMappedStatement<T, ID> { public static <T, ID> MappedUpdateId<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) throws SQLException { FieldType idField = tableInfo.getIdField(); if (idField == null) { throw new SQLException("Cannot update-id in " + tableInfo.getDataClass() + " because it doesn't have an id field"); } StringBuilder sb = new StringBuilder(64); appendTableName(databaseType, sb, "UPDATE ", tableInfo.getTableName()); sb.append("SET "); appendFieldColumnName(databaseType, sb, idField, null); sb.append("= ? "); appendWhereFieldEq(databaseType, idField, sb, null); return new MappedUpdateId<T, ID>(tableInfo, sb.toString(), new FieldType[] { idField, idField }); } private MappedUpdateId(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); int execute(DatabaseConnection databaseConnection, T data, ID newId, ObjectCache objectCache); static MappedUpdateId<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); }### Answer:
@Test(expected = SQLException.class) public void testUpdateIdNoId() throws Exception { MappedUpdateId.build(databaseType, new TableInfo<NoId, Void>(connectionSource, null, NoId.class)); } |
### Question:
MappedDelete extends BaseMappedStatement<T, ID> { public int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { try { Object[] args = getFieldObjects(data); int rowC = databaseConnection.delete(statement, args, argFieldTypes); logger.debug("delete data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("delete arguments: {}", (Object) args); } if (rowC > 0 && objectCache != null) { Object id = idField.extractJavaFieldToSqlArgValue(data); objectCache.remove(clazz, id); } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run delete stmt on object " + data + ": " + statement, e); } } private MappedDelete(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); static MappedDelete<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache); int deleteById(DatabaseConnection databaseConnection, ID id, ObjectCache objectCache); }### Answer:
@Test(expected = SQLException.class) public void testDeleteNoId() throws Exception { StatementExecutor<NoId, Void> se = new StatementExecutor<NoId, Void>(databaseType, new TableInfo<NoId, Void>(connectionSource, null, NoId.class), null); NoId noId = new NoId(); noId.stuff = "1"; ConnectionSource connectionSource = createMock(ConnectionSource.class); expect(connectionSource.getReadOnlyConnection(NOID_TABLE_NAME)).andReturn(null); replay(connectionSource); se.delete(connectionSource.getReadOnlyConnection(NOID_TABLE_NAME), noId, null); } |
### Question:
MappedDelete extends BaseMappedStatement<T, ID> { public static <T, ID> MappedDelete<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) throws SQLException { FieldType idField = tableInfo.getIdField(); if (idField == null) { throw new SQLException("Cannot delete from " + tableInfo.getDataClass() + " because it doesn't have an id field"); } StringBuilder sb = new StringBuilder(64); appendTableName(databaseType, sb, "DELETE FROM ", tableInfo.getTableName()); appendWhereFieldEq(databaseType, idField, sb, null); return new MappedDelete<T, ID>(tableInfo, sb.toString(), new FieldType[] { idField }); } private MappedDelete(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes); static MappedDelete<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); int delete(DatabaseConnection databaseConnection, T data, ObjectCache objectCache); int deleteById(DatabaseConnection databaseConnection, ID id, ObjectCache objectCache); }### Answer:
@Test(expected = SQLException.class) public void testNoIdBuildDelete() throws Exception { MappedDelete.build(databaseType, new TableInfo<NoId, Void>(connectionSource, null, NoId.class)); } |
### Question:
MappedUpdate extends BaseMappedStatement<T, ID> { public int update(DatabaseConnection databaseConnection, T data, ObjectCache objectCache) throws SQLException { try { if (argFieldTypes.length <= 1) { return 0; } Object[] args = getFieldObjects(data); Object newVersion = null; if (versionFieldType != null) { newVersion = versionFieldType.extractJavaFieldValue(data); newVersion = versionFieldType.moveToNextValue(newVersion); args[versionFieldTypeIndex] = versionFieldType.convertJavaFieldToSqlArgValue(newVersion); } int rowC = databaseConnection.update(statement, args, argFieldTypes); if (rowC > 0) { if (newVersion != null) { versionFieldType.assignField(data, newVersion, false, null); } if (objectCache != null) { Object id = idField.extractJavaFieldValue(data); T cachedData = objectCache.get(clazz, id); if (cachedData != null && cachedData != data) { for (FieldType fieldType : tableInfo.getFieldTypes()) { if (fieldType != idField) { fieldType.assignField(cachedData, fieldType.extractJavaFieldValue(data), false, objectCache); } } } } } logger.debug("update data with statement '{}' and {} args, changed {} rows", statement, args.length, rowC); if (args.length > 0) { logger.trace("update arguments: {}", (Object) args); } return rowC; } catch (SQLException e) { throw SqlExceptionUtil.create("Unable to run update stmt on object " + data + ": " + statement, e); } } private MappedUpdate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
FieldType versionFieldType, int versionFieldTypeIndex); static MappedUpdate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); int update(DatabaseConnection databaseConnection, T data, ObjectCache objectCache); }### Answer:
@Test(expected = SQLException.class) public void testUpdateNoId() throws Exception { StatementExecutor<NoId, String> se = new StatementExecutor<NoId, String>(databaseType, new TableInfo<NoId, String>(connectionSource, null, NoId.class), null); NoId noId = new NoId(); noId.id = "1"; se.update(null, noId, null); }
@Test public void testUpdateJustId() throws Exception { StatementExecutor<JustId, Integer> se = new StatementExecutor<JustId, Integer>(databaseType, new TableInfo<JustId, Integer>(connectionSource, null, JustId.class), null); JustId justId = new JustId(); justId.id = 1; assertEquals(0, se.update(null, justId, null)); } |
### Question:
MappedUpdate extends BaseMappedStatement<T, ID> { public static <T, ID> MappedUpdate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo) throws SQLException { FieldType idField = tableInfo.getIdField(); if (idField == null) { throw new SQLException("Cannot update " + tableInfo.getDataClass() + " because it doesn't have an id field"); } StringBuilder sb = new StringBuilder(64); appendTableName(databaseType, sb, "UPDATE ", tableInfo.getTableName()); boolean first = true; int argFieldC = 0; FieldType versionFieldType = null; int versionFieldTypeIndex = -1; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (isFieldUpdatable(fieldType, idField)) { if (fieldType.isVersion()) { versionFieldType = fieldType; versionFieldTypeIndex = argFieldC; } argFieldC++; } } argFieldC++; if (versionFieldType != null) { argFieldC++; } FieldType[] argFieldTypes = new FieldType[argFieldC]; argFieldC = 0; for (FieldType fieldType : tableInfo.getFieldTypes()) { if (!isFieldUpdatable(fieldType, idField)) { continue; } if (first) { sb.append("SET "); first = false; } else { sb.append(", "); } appendFieldColumnName(databaseType, sb, fieldType, null); argFieldTypes[argFieldC++] = fieldType; sb.append("= ?"); } sb.append(' '); appendWhereFieldEq(databaseType, idField, sb, null); argFieldTypes[argFieldC++] = idField; if (versionFieldType != null) { sb.append(" AND "); appendFieldColumnName(databaseType, sb, versionFieldType, null); sb.append("= ?"); argFieldTypes[argFieldC++] = versionFieldType; } return new MappedUpdate<T, ID>(tableInfo, sb.toString(), argFieldTypes, versionFieldType, versionFieldTypeIndex); } private MappedUpdate(TableInfo<T, ID> tableInfo, String statement, FieldType[] argFieldTypes,
FieldType versionFieldType, int versionFieldTypeIndex); static MappedUpdate<T, ID> build(DatabaseType databaseType, TableInfo<T, ID> tableInfo); int update(DatabaseConnection databaseConnection, T data, ObjectCache objectCache); }### Answer:
@Test(expected = SQLException.class) public void testNoIdBuildUpdater() throws Exception { MappedUpdate.build(databaseType, new TableInfo<NoId, Void>(connectionSource, null, NoId.class)); }
@Test(expected = SQLException.class) public void testJustIdBuildUpdater() throws Exception { MappedUpdate.build(databaseType, new TableInfo<NoId, Void>(connectionSource, null, NoId.class)); } |
### Question:
NullArgHolder implements ArgumentHolder { @Override public void setValue(Object value) { throw new UnsupportedOperationException("Cannot set null on " + getClass()); } NullArgHolder(); @Override String getColumnName(); @Override void setValue(Object value); @Override void setMetaInfo(String columnName); @Override void setMetaInfo(FieldType fieldType); @Override void setMetaInfo(String columnName, FieldType fieldType); @Override Object getSqlArgValue(); @Override SqlType getSqlType(); @Override FieldType getFieldType(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testSetValueThrows() { new NullArgHolder().setValue(null); } |
### Question:
Elements extends ArrayList<Element> { public String html() { StringBuilder sb = new StringBuilder(); for (Element element : this) { if (sb.length() != 0) sb.append("\n"); sb.append(element.html()); } return sb.toString(); } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void html() { Document doc = Jsoup.parse("<div><p>Hello</p></div><div><p>There</p></div>"); Elements divs = doc.select("div"); assertEquals("<p>Hello</p>\n<p>There</p>", divs.html()); } |
### Question:
SelectArg extends BaseArgumentHolder { @Override public void setValue(Object value) { this.hasBeenSet = true; this.value = value; } SelectArg(); SelectArg(String columnName, Object value); SelectArg(SqlType sqlType, Object value); SelectArg(SqlType sqlType); SelectArg(Object value); @Override void setValue(Object value); }### Answer:
@Test public void testSetValue() throws Exception { SelectArg selectArg = new SelectArg(); Object foo = new Object(); selectArg.setValue(foo); assertSame(foo, selectArg.getSqlArgValue()); }
@Test public void testSetNumber() throws Exception { SelectArg selectArg = new SelectArg(); int val = 10; selectArg.setMetaInfo("val", numberFieldType); selectArg.setValue(val); assertSame(val, selectArg.getSqlArgValue()); }
@Test public void testSetNullValue() throws Exception { SelectArg selectArg = new SelectArg(); selectArg.setValue(null); assertNull(selectArg.getSqlArgValue()); }
@Test public void testForeignValue() { SelectArg selectArg = new SelectArg(); assertTrue(selectArg.toString().contains("[unset]")); Foo foo = new Foo(); selectArg.setValue(foo); selectArg.setMetaInfo("id", foreignFieldType); assertTrue(selectArg + " wrong value", selectArg.toString().contains(Integer.toString(foo.id))); }
@Test public void testToString() { SelectArg selectArg = new SelectArg(); assertTrue(selectArg.toString().contains("[unset]")); selectArg.setValue(null); assertTrue(selectArg.toString().contains("[null]")); String value = "fwefefewf"; selectArg.setValue(value); assertTrue(selectArg.toString().contains(value)); } |
### Question:
Elements extends ArrayList<Element> { public String outerHtml() { StringBuilder sb = new StringBuilder(); for (Element element : this) { if (sb.length() != 0) sb.append("\n"); sb.append(element.outerHtml()); } return sb.toString(); } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void outerHtml() { Document doc = Jsoup.parse("<div><p>Hello</p></div><div><p>There</p></div>"); Elements divs = doc.select("div"); assertEquals("<div><p>Hello</p></div><div><p>There</p></div>", TextUtil.stripNewlines(divs.outerHtml())); } |
### Question:
Where { @Override public String toString() { if (clauseStackLevel == 0) { return "empty where clause"; } else { Clause clause = peek(); return "where clause: " + clause; } } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testToString() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); assertTrue(where.toString().contains("empty where clause")); String value = "bar"; FieldType numberFieldType = FieldType.createFieldType(connectionSource, "foo", Foo.class.getDeclaredField(Foo.VAL_COLUMN_NAME), Foo.class); SimpleComparison eq = new SimpleComparison(Foo.VAL_COLUMN_NAME, numberFieldType, value, SimpleComparison.EQUAL_TO_OPERATION); where.eq(Foo.VAL_COLUMN_NAME, value); assertTrue(where.toString().contains(eq.toString())); } |
### Question:
Where { void appendSql(String tableName, StringBuilder sb, List<ArgumentHolder> columnArgList) throws SQLException { if (clauseStackLevel == 0) { throw new IllegalStateException("No where clauses defined. Did you miss a where operation?"); } if (clauseStackLevel != 1) { throw new IllegalStateException( "Both the \"left-hand\" and \"right-hand\" clauses have been defined. Did you miss an AND or OR?"); } if (needsFuture != null) { throw new IllegalStateException( "The SQL statement has not been finished since there are previous operations still waiting for clauses."); } peek().appendSql(databaseType, tableName, sb, columnArgList); } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test(expected = IllegalStateException.class) public void testNoClauses() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); where.appendSql(null, new StringBuilder(), new ArrayList<ArgumentHolder>()); } |
### Question:
Where { public Where<T, ID> eq(String columnName, Object value) throws SQLException { addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value, SimpleComparison.EQUAL_TO_OPERATION)); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testComparisonUnknownField() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); int val = 1; where.eq("unknown-field", val); }
@Test(expected = IllegalArgumentException.class) public void testComparisonFieldNameNotColumnName() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); assertNotNull(Foo.class.getDeclaredField(Foo.ID_COLUMN_NAME)); int val = 1; where.eq("stringField", val); }
@Test public void testEq() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); int val = 112; where.eq(Foo.VAL_COLUMN_NAME, val); testOperation(where, Foo.VAL_COLUMN_NAME, "=", val); } |
### Question:
Where { public Where<T, ID> between(String columnName, Object low, Object high) throws SQLException { addClause(new Between(columnName, findColumnFieldType(columnName), low, high)); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testBetween() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); int low = 1; int high = 1; where.between(Foo.VAL_COLUMN_NAME, low, high); StringBuilder whereSb = new StringBuilder(); where.appendSql(null, whereSb, new ArrayList<ArgumentHolder>()); StringBuilder sb = new StringBuilder(); databaseType.appendEscapedEntityName(sb, Foo.VAL_COLUMN_NAME); sb.append(" BETWEEN ").append(low); sb.append(" AND ").append(high); sb.append(' '); assertEquals(sb.toString(), whereSb.toString()); } |
### Question:
Where { public Where<T, ID> ge(String columnName, Object value) throws SQLException { addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value, SimpleComparison.GREATER_THAN_EQUAL_TO_OPERATION)); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testGe() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); int val = 112; where.ge(Foo.VAL_COLUMN_NAME, val); testOperation(where, Foo.VAL_COLUMN_NAME, ">=", val); } |
### Question:
Where { public Where<T, ID> gt(String columnName, Object value) throws SQLException { addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value, SimpleComparison.GREATER_THAN_OPERATION)); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testGt() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); int val = 112; where.gt(Foo.VAL_COLUMN_NAME, val); testOperation(where, Foo.VAL_COLUMN_NAME, ">", val); } |
### Question:
Elements extends ArrayList<Element> { public String val() { if (size() > 0) return first().val(); else return ""; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void val() { Document doc = Jsoup.parse("<input value='one' /><textarea>two</textarea>"); Elements els = doc.select("input, textarea"); assertEquals(2, els.size()); assertEquals("one", els.val()); assertEquals("two", els.last().val()); els.val("three"); assertEquals("three", els.first().val()); assertEquals("three", els.last().val()); assertEquals("<textarea>three</textarea>", els.last().outerHtml()); } |
### Question:
Where { public Where<T, ID> lt(String columnName, Object value) throws SQLException { addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value, SimpleComparison.LESS_THAN_OPERATION)); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testLt() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); int val = 112; where.lt(Foo.VAL_COLUMN_NAME, val); testOperation(where, Foo.VAL_COLUMN_NAME, "<", val); } |
### Question:
Where { public Where<T, ID> le(String columnName, Object value) throws SQLException { addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value, SimpleComparison.LESS_THAN_EQUAL_TO_OPERATION)); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testLe() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); int val = 112; where.le(Foo.VAL_COLUMN_NAME, val); testOperation(where, Foo.VAL_COLUMN_NAME, "<=", val); } |
### Question:
Where { public Where<T, ID> ne(String columnName, Object value) throws SQLException { addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value, SimpleComparison.NOT_EQUAL_TO_OPERATION)); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testNe() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); int val = 112; where.ne(Foo.VAL_COLUMN_NAME, val); testOperation(where, Foo.VAL_COLUMN_NAME, "<>", val); } |
### Question:
Where { public Where<T, ID> notIn(String columnName, Iterable<?> objects) throws SQLException { addClause(new In(columnName, findColumnFieldType(columnName), objects, false)); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testNotIn() throws Exception { Dao<Foo, String> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); foo1.val = 63465365; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); foo2 = new Foo(); foo2.val = 163123; assertEquals(1, dao.create(foo2)); List<Foo> results = dao.queryBuilder().where().in(Foo.ID_COLUMN_NAME, foo2.id).query(); assertEquals(1, results.size()); assertEquals(foo2.val, results.get(0).val); results = dao.queryBuilder().where().not().in(Foo.ID_COLUMN_NAME, foo2.id).query(); assertEquals(1, results.size()); assertEquals(foo1.val, results.get(0).val); results = dao.queryBuilder().where().notIn(Foo.ID_COLUMN_NAME, foo2.id).query(); assertEquals(1, results.size()); assertEquals(foo1.val, results.get(0).val); } |
### Question:
Where { public Where<T, ID> isNull(String columnName) throws SQLException { addClause(new IsNull(columnName, findColumnFieldType(columnName))); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testIsNull() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); where.isNull(Foo.VAL_COLUMN_NAME); StringBuilder whereSb = new StringBuilder(); where.appendSql(null, whereSb, new ArrayList<ArgumentHolder>()); StringBuilder sb = new StringBuilder(); databaseType.appendEscapedEntityName(sb, Foo.VAL_COLUMN_NAME); sb.append(" IS NULL "); assertEquals(sb.toString(), whereSb.toString()); } |
### Question:
Where { public Where<T, ID> isNotNull(String columnName) throws SQLException { addClause(new IsNotNull(columnName, findColumnFieldType(columnName))); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testIsNotNull() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); where.isNotNull(Foo.VAL_COLUMN_NAME); StringBuilder whereSb = new StringBuilder(); where.appendSql(null, whereSb, new ArrayList<ArgumentHolder>()); StringBuilder sb = new StringBuilder(); databaseType.appendEscapedEntityName(sb, Foo.VAL_COLUMN_NAME); sb.append(" IS NOT NULL "); assertEquals(sb.toString(), whereSb.toString()); } |
### Question:
Where { public Where<T, ID> like(String columnName, Object value) throws SQLException { addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value, SimpleComparison.LIKE_OPERATION)); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testLike() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); int val = 112; where.like(Foo.VAL_COLUMN_NAME, val); StringBuilder whereSb = new StringBuilder(); where.appendSql(null, whereSb, new ArrayList<ArgumentHolder>()); StringBuilder sb = new StringBuilder(); databaseType.appendEscapedEntityName(sb, Foo.VAL_COLUMN_NAME); sb.append(" LIKE "); sb.append(val).append(' '); assertEquals(sb.toString(), whereSb.toString()); } |
### Question:
Where { public Where<T, ID> idEq(ID id) throws SQLException { if (idColumnName == null) { throw new SQLException("Object has no id column specified"); } addClause(new SimpleComparison(idColumnName, idFieldType, id, SimpleComparison.EQUAL_TO_OPERATION)); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testIdEq() throws Exception { Where<FooId, Integer> where = new Where<FooId, Integer>(new TableInfo<FooId, Integer>(connectionSource, null, FooId.class), null, databaseType); int val = 112; where.idEq(val); StringBuilder whereSb = new StringBuilder(); where.appendSql(null, whereSb, new ArrayList<ArgumentHolder>()); StringBuilder sb = new StringBuilder(); databaseType.appendEscapedEntityName(sb, ID_COLUMN_NAME); sb.append(" = ").append(val); sb.append(' '); assertEquals(sb.toString(), whereSb.toString()); }
@Test(expected = SQLException.class) public void testIdEqNoId() throws Exception { new Where<FooNoId, Integer>(new TableInfo<FooNoId, Integer>(connectionSource, null, FooNoId.class), null, databaseType).idEq(100); }
@Test(expected = SQLException.class) public void testIdEqObjectIdNoId() throws Exception { new Where<FooNoId, Integer>(new TableInfo<FooNoId, Integer>(connectionSource, null, FooNoId.class), null, databaseType).idEq(new BaseDaoImpl<FooNoId, Integer>(connectionSource, FooNoId.class) { }, new FooNoId()); } |
### Question:
Elements extends ArrayList<Element> { public Elements before(String html) { for (Element element : this) { element.before(html); } return this; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void before() { Document doc = Jsoup.parse("<p>This <a>is</a> <a>jsoup</a>.</p>"); doc.select("a").before("<span>foo</span>"); assertEquals("<p>This <span>foo</span><a>is</a> <span>foo</span><a>jsoup</a>.</p>", TextUtil.stripNewlines(doc.body().html())); } |
### Question:
Where { public Where<T, ID> raw(String rawStatement, ArgumentHolder... args) { for (ArgumentHolder arg : args) { String columnName = arg.getColumnName(); if (columnName == null) { if (arg.getSqlType() == null) { throw new IllegalArgumentException("Either the column name or SqlType must be set on each argument"); } } else { arg.setMetaInfo(findColumnFieldType(columnName)); } } addClause(new Raw(rawStatement, args)); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testRaw() throws Exception { TableInfo<Foo, Integer> tableInfo = new TableInfo<Foo, Integer>(connectionSource, null, Foo.class); Where<Foo, Integer> where = new Where<Foo, Integer>(tableInfo, null, databaseType); String raw = "VAL = 1"; int val = 17; where.eq(Foo.VAL_COLUMN_NAME, val).and().raw(raw); StringBuilder whereSb = new StringBuilder(); where.appendSql(null, whereSb, new ArrayList<ArgumentHolder>()); StringBuilder sb = new StringBuilder(); sb.append('('); databaseType.appendEscapedEntityName(sb, Foo.VAL_COLUMN_NAME); sb.append(" = ").append(val); sb.append(" AND ").append(raw).append(" ) "); assertEquals(sb.toString(), whereSb.toString()); } |
### Question:
Where { public Where<T, ID> rawComparison(String columnName, String rawOperator, Object value) throws SQLException { addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value, rawOperator)); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test public void testRawComparison() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo = new Foo(); int val = 63465365; foo.val = val; assertEquals(1, dao.create(foo)); QueryBuilder<Foo, Integer> qb = dao.queryBuilder(); qb.where().rawComparison("id", "=", new SelectArg(foo.id)); List<Foo> results = qb.query(); assertNotNull(results); assertEquals(1, results.size()); assertEquals(val, results.get(0).val); } |
### Question:
Where { public Where<T, ID> or() { ManyClause clause = new ManyClause(pop("OR"), ManyClause.OR_OPERATION); push(clause); addNeedsFuture(clause); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testOrManyZero() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); where.or(0); } |
### Question:
Where { public Where<T, ID> and() { ManyClause clause = new ManyClause(pop("AND"), ManyClause.AND_OPERATION); push(clause); addNeedsFuture(clause); return this; } protected Where(TableInfo<T, ID> tableInfo, StatementBuilder<T, ID> statementBuilder, DatabaseType databaseType); Where<T, ID> and(); Where<T, ID> and(Where<T, ID> first, Where<T, ID> second, Where<T, ID>... others); Where<T, ID> and(int numClauses); Where<T, ID> between(String columnName, Object low, Object high); Where<T, ID> eq(String columnName, Object value); Where<T, ID> ge(String columnName, Object value); Where<T, ID> gt(String columnName, Object value); Where<T, ID> in(String columnName, Iterable<?> objects); Where<T, ID> notIn(String columnName, Iterable<?> objects); Where<T, ID> in(String columnName, Object... objects); Where<T, ID> notIn(String columnName, Object... objects); Where<T, ID> in(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> notIn(String columnName, QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> exists(QueryBuilder<?, ?> subQueryBuilder); Where<T, ID> isNull(String columnName); Where<T, ID> isNotNull(String columnName); Where<T, ID> le(String columnName, Object value); Where<T, ID> lt(String columnName, Object value); Where<T, ID> like(String columnName, Object value); Where<T, ID> ne(String columnName, Object value); Where<T, ID> not(); Where<T, ID> not(Where<T, ID> comparison); Where<T, ID> or(); Where<T, ID> or(Where<T, ID> left, Where<T, ID> right, Where<T, ID>... others); Where<T, ID> or(int numClauses); Where<T, ID> idEq(ID id); Where<T, ID> idEq(Dao<OD, ?> dataDao, OD data); Where<T, ID> raw(String rawStatement, ArgumentHolder... args); Where<T, ID> rawComparison(String columnName, String rawOperator, Object value); PreparedQuery<T> prepare(); List<T> query(); GenericRawResults<String[]> queryRaw(); T queryForFirst(); String[] queryRawFirst(); long countOf(); CloseableIterator<T> iterator(); Where<T, ID> reset(); String getStatement(); @Override String toString(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testAndManyZero() throws Exception { Where<Foo, String> where = new Where<Foo, String>(createTableInfo(), null, databaseType); where.and(0); } |
### Question:
UpdateBuilder extends StatementBuilder<T, ID> { public UpdateBuilder<T, ID> updateColumnValue(String columnName, Object value) throws SQLException { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new SQLException("Can't update foreign colletion field: " + columnName); } addUpdateColumnToList(columnName, new SetValue(columnName, fieldType, value)); return this; } UpdateBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedUpdate<T> prepare(); UpdateBuilder<T, ID> updateColumnValue(String columnName, Object value); UpdateBuilder<T, ID> updateColumnExpression(String columnName, String expression); void escapeColumnName(StringBuilder sb, String columnName); String escapeColumnName(String columnName); void escapeValue(StringBuilder sb, String value); String escapeValue(String value); int update(); @Override void reset(); }### Answer:
@Test(expected = SQLException.class) public void testUpdateForeignCollection() throws Exception { UpdateBuilder<OurForeignCollection, Integer> stmtb = new UpdateBuilder<OurForeignCollection, Integer>( databaseType, new TableInfo<OurForeignCollection, Integer>(connectionSource, null, OurForeignCollection.class), null); stmtb.updateColumnValue(OurForeignCollection.FOOS_FIELD_NAME, null); } |
### Question:
UpdateBuilder extends StatementBuilder<T, ID> { public UpdateBuilder<T, ID> updateColumnExpression(String columnName, String expression) throws SQLException { FieldType fieldType = verifyColumnName(columnName); if (fieldType.isForeignCollection()) { throw new SQLException("Can't update foreign colletion field: " + columnName); } addUpdateColumnToList(columnName, new SetExpression(columnName, fieldType, expression)); return this; } UpdateBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedUpdate<T> prepare(); UpdateBuilder<T, ID> updateColumnValue(String columnName, Object value); UpdateBuilder<T, ID> updateColumnExpression(String columnName, String expression); void escapeColumnName(StringBuilder sb, String columnName); String escapeColumnName(String columnName); void escapeValue(StringBuilder sb, String value); String escapeValue(String value); int update(); @Override void reset(); }### Answer:
@Test(expected = SQLException.class) public void testUpdateForeignCollectionColumnExpression() throws Exception { UpdateBuilder<OurForeignCollection, Integer> stmtb = new UpdateBuilder<OurForeignCollection, Integer>( databaseType, new TableInfo<OurForeignCollection, Integer>(connectionSource, null, OurForeignCollection.class), null); stmtb.updateColumnExpression(OurForeignCollection.FOOS_FIELD_NAME, "1"); } |
### Question:
UpdateBuilder extends StatementBuilder<T, ID> { public PreparedUpdate<T> prepare() throws SQLException { return super.prepareStatement(null, false); } UpdateBuilder(DatabaseType databaseType, TableInfo<T, ID> tableInfo, Dao<T, ID> dao); PreparedUpdate<T> prepare(); UpdateBuilder<T, ID> updateColumnValue(String columnName, Object value); UpdateBuilder<T, ID> updateColumnExpression(String columnName, String expression); void escapeColumnName(StringBuilder sb, String columnName); String escapeColumnName(String columnName); void escapeValue(StringBuilder sb, String value); String escapeValue(String value); int update(); @Override void reset(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testPrepareStatementUpdateNotSets() throws Exception { UpdateBuilder<Foo, Integer> stmtb = new UpdateBuilder<Foo, Integer>(databaseType, baseFooTableInfo, null); stmtb.prepare(); } |
### Question:
Elements extends ArrayList<Element> { public Elements after(String html) { for (Element element : this) { element.after(html); } return this; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void after() { Document doc = Jsoup.parse("<p>This <a>is</a> <a>jsoup</a>.</p>"); doc.select("a").after("<span>foo</span>"); assertEquals("<p>This <a>is</a><span>foo</span> <a>jsoup</a><span>foo</span>.</p>", TextUtil.stripNewlines(doc.body().html())); } |
### Question:
Statements { public List<Statement> getStatements() { return statements; } List<Statement> getStatements(); void setStatements(List<Statement> statements); void accept(StatementVisitor statementVisitor); @Override String toString(); }### Answer:
@Test public void testStatementsErrorRecovery() throws JSQLParserException, ParseException { String sqls = "select * from mytable; select * from;"; CCJSqlParser parser = new CCJSqlParser(new StringReader(sqls)); parser.setErrorRecovery(true); Statements parseStatements = parser.Statements(); assertEquals(2, parseStatements.getStatements().size()); assertTrue(parseStatements.getStatements().get(0) instanceof Select); assertNull(parseStatements.getStatements().get(1)); }
@Test public void testStatementsErrorRecovery2() throws JSQLParserException, ParseException { String sqls = "select * from1 table;"; CCJSqlParser parser = new CCJSqlParser(new StringReader(sqls)); parser.setErrorRecovery(true); Statements parseStatements = parser.Statements(); assertEquals(1, parseStatements.getStatements().size()); assertTrue(parseStatements.getStatements().get(0) instanceof Select); assertEquals(1,parser.getParseErrors().size()); }
@Test public void testStatementsErrorRecovery3() throws JSQLParserException, ParseException { String sqls = "select * from mytable; select * from;select * from mytable2"; CCJSqlParser parser = new CCJSqlParser(new StringReader(sqls)); parser.setErrorRecovery(true); Statements parseStatements = parser.Statements(); assertEquals(2, parseStatements.getStatements().size()); assertTrue(parseStatements.getStatements().get(0) instanceof Select); assertNull(parseStatements.getStatements().get(1)); assertEquals(2,parser.getParseErrors().size()); } |
### Question:
Execute implements Statement { @Override public void accept(StatementVisitor statementVisitor) { statementVisitor.visit(this); } String getName(); void setName(String name); ExpressionList getExprList(); void setExprList(ExpressionList exprList); @Override void accept(StatementVisitor statementVisitor); @Override String toString(); }### Answer:
@Test public void testAccept() throws JSQLParserException { assertSqlCanBeParsedAndDeparsed("EXECUTE myproc 'a', 2, 'b'"); } |
### Question:
Elements extends ArrayList<Element> { public Elements wrap(String html) { Validate.notEmpty(html); for (Element element : this) { element.wrap(html); } return this; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void wrap() { String h = "<p><b>This</b> is <b>jsoup</b></p>"; Document doc = Jsoup.parse(h); doc.select("b").wrap("<i></i>"); assertEquals("<p><i><b>This</b></i> is <i><b>jsoup</b></i></p>", doc.body().html()); } |
### Question:
Elements extends ArrayList<Element> { public Elements unwrap() { for (Element element : this) { element.unwrap(); } return this; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void unwrap() { String h = "<div><font>One</font> <font><a href=\"/\">Two</a></font></div"; Document doc = Jsoup.parse(h); doc.select("font").unwrap(); assertEquals("<div>One <a href=\"/\">Two</a></div>", TextUtil.stripNewlines(doc.body().html())); } |
### Question:
TypeHandlerRegistry { public static <T> TypeHandler<T> getTypeHandler(Class<T> type) { return getTypeHandler(type, null); } static boolean hasTypeHandler(Class<?> javaType); @Nullable static TypeHandler<T> getNullableTypeHandler(Class<T> type); static TypeHandler<T> getTypeHandler(Class<T> type); @Nullable static TypeHandler<T> getNullableTypeHandler(Class<T> type, JdbcType jdbcType); static TypeHandler<T> getTypeHandler(Class<T> type, JdbcType jdbcType); static void register(Class<T> javaType, TypeHandler<? extends T> typeHandler); static void register(Class<T> type, JdbcType jdbcType, TypeHandler<? extends T> handler); }### Answer:
@Test public void testException() throws Exception { thrown.expect(TypeException.class); thrown.expectMessage("Can't get type handle, java type is 'class java.lang.StringBuffer', jdbc type is 'null'"); TypeHandlerRegistry.getTypeHandler(StringBuffer.class); } |
### Question:
SelectUtils { public static void addExpression(Select select, final Expression expr) { select.getSelectBody().accept(new SelectVisitor() { @Override public void visit(PlainSelect plainSelect) { plainSelect.getSelectItems().add(new SelectExpressionItem(expr)); } @Override public void visit(SetOperationList setOpList) { throw new UnsupportedOperationException(NOT_SUPPORTED_YET); } @Override public void visit(WithItem withItem) { throw new UnsupportedOperationException(NOT_SUPPORTED_YET); } }); } private SelectUtils(); static Select buildSelectFromTableAndExpressions(Table table, Expression ... expr); static Select buildSelectFromTableAndExpressions(Table table, String ... expr); static Select buildSelectFromTableAndSelectItems(Table table, SelectItem ... selectItems); static Select buildSelectFromTable(Table table); static void addExpression(Select select, final Expression expr); static Join addJoin(Select select, final Table table, final Expression onExpression); static void addGroupBy(Select select, final Expression expr); }### Answer:
@Test public void testAddExpr() throws JSQLParserException { Select select = (Select) CCJSqlParserUtil.parse("select a from mytable"); SelectUtils.addExpression(select, new Column("b")); assertEquals("SELECT a, b FROM mytable", select.toString()); Addition add = new Addition(); add.setLeftExpression(new LongValue(5)); add.setRightExpression(new LongValue(6)); SelectUtils.addExpression(select, add); assertEquals("SELECT a, b, 5 + 6 FROM mytable", select.toString()); } |
### Question:
SelectUtils { public static Join addJoin(Select select, final Table table, final Expression onExpression) { if (select.getSelectBody() instanceof PlainSelect) { PlainSelect plainSelect = (PlainSelect) select.getSelectBody(); List<Join> joins = plainSelect.getJoins(); if (joins == null) { joins = new ArrayList<Join>(); plainSelect.setJoins(joins); } Join join = new Join(); join.setRightItem(table); join.setOnExpression(onExpression); joins.add(join); return join; } throw new UnsupportedOperationException(NOT_SUPPORTED_YET); } private SelectUtils(); static Select buildSelectFromTableAndExpressions(Table table, Expression ... expr); static Select buildSelectFromTableAndExpressions(Table table, String ... expr); static Select buildSelectFromTableAndSelectItems(Table table, SelectItem ... selectItems); static Select buildSelectFromTable(Table table); static void addExpression(Select select, final Expression expr); static Join addJoin(Select select, final Table table, final Expression onExpression); static void addGroupBy(Select select, final Expression expr); }### Answer:
@Test public void testAddJoin() throws JSQLParserException { Select select = (Select)CCJSqlParserUtil.parse("select a from mytable"); final EqualsTo equalsTo = new EqualsTo(); equalsTo.setLeftExpression(new Column("a")); equalsTo.setRightExpression(new Column("b")); Join addJoin = SelectUtils.addJoin(select, new Table("mytable2"), equalsTo); addJoin.setLeft(true); assertEquals("SELECT a FROM mytable LEFT JOIN mytable2 ON a = b", select.toString()); } |
### Question:
SelectUtils { public static Select buildSelectFromTableAndExpressions(Table table, Expression ... expr) { SelectItem[] list = new SelectItem[expr.length]; for (int i=0;i<expr.length;i++) { list[i]=new SelectExpressionItem(expr[i]); } return buildSelectFromTableAndSelectItems(table, list); } private SelectUtils(); static Select buildSelectFromTableAndExpressions(Table table, Expression ... expr); static Select buildSelectFromTableAndExpressions(Table table, String ... expr); static Select buildSelectFromTableAndSelectItems(Table table, SelectItem ... selectItems); static Select buildSelectFromTable(Table table); static void addExpression(Select select, final Expression expr); static Join addJoin(Select select, final Table table, final Expression onExpression); static void addGroupBy(Select select, final Expression expr); }### Answer:
@Test public void testBuildSelectFromTableAndExpressions() { Select select = SelectUtils.buildSelectFromTableAndExpressions(new Table("mytable"), new Column("a"), new Column("b")); assertEquals("SELECT a, b FROM mytable", select.toString()); }
@Test public void testBuildSelectFromTableAndParsedExpression() throws JSQLParserException { Select select = SelectUtils.buildSelectFromTableAndExpressions(new Table("mytable"), "a+b", "test"); assertEquals("SELECT a + b, test FROM mytable", select.toString()); assertTrue(((SelectExpressionItem)((PlainSelect)select.getSelectBody()).getSelectItems().get(0)).getExpression() instanceof Addition); } |
### Question:
SelectUtils { public static Select buildSelectFromTable(Table table) { return buildSelectFromTableAndSelectItems(table, new AllColumns()); } private SelectUtils(); static Select buildSelectFromTableAndExpressions(Table table, Expression ... expr); static Select buildSelectFromTableAndExpressions(Table table, String ... expr); static Select buildSelectFromTableAndSelectItems(Table table, SelectItem ... selectItems); static Select buildSelectFromTable(Table table); static void addExpression(Select select, final Expression expr); static Join addJoin(Select select, final Table table, final Expression onExpression); static void addGroupBy(Select select, final Expression expr); }### Answer:
@Test public void testBuildSelectFromTable() { Select select = SelectUtils.buildSelectFromTable(new Table("mytable")); assertEquals("SELECT * FROM mytable", select.toString()); } |
### Question:
Elements extends ArrayList<Element> { public Elements empty() { for (Element element : this) { element.empty(); } return this; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void empty() { Document doc = Jsoup.parse("<div><p>Hello <b>there</b></p> <p>now!</p></div>"); doc.outputSettings().prettyPrint(false); doc.select("p").empty(); assertEquals("<div><p></p> <p></p></div>", doc.body().html()); } |
### Question:
CCJSqlParserUtil { public static Expression parseExpression(String expression) throws JSQLParserException { CCJSqlParser parser = new CCJSqlParser(new StringReader(expression)); try { return parser.SimpleExpression(); } catch (Exception ex) { throw new JSQLParserException(ex); } } private CCJSqlParserUtil(); static Statement parse(Reader statementReader); static Statement parse(String sql); static Node parseAST(String sql); static Statement parse(InputStream is); static Statement parse(InputStream is, String encoding); static Expression parseExpression(String expression); static Expression parseCondExpression(String condExpr); static Statements parseStatements(String sqls); }### Answer:
@Test public void testParseExpression() throws Exception { Expression result = CCJSqlParserUtil.parseExpression("a+b"); assertEquals("a + b", result.toString()); assertTrue(result instanceof Addition); Addition add = (Addition)result; assertTrue(add.getLeftExpression() instanceof Column); assertTrue(add.getRightExpression() instanceof Column); }
@Test public void testParseExpression2() throws Exception { Expression result = CCJSqlParserUtil.parseExpression("2*(a+6.0)"); assertEquals("2 * (a + 6.0)", result.toString()); assertTrue(result instanceof Multiplication); Multiplication mult = (Multiplication)result; assertTrue(mult.getLeftExpression() instanceof LongValue); assertTrue(mult.getRightExpression() instanceof Parenthesis); } |
### Question:
CCJSqlParserUtil { public static Expression parseCondExpression(String condExpr) throws JSQLParserException { CCJSqlParser parser = new CCJSqlParser(new StringReader(condExpr)); try { return parser.Expression(); } catch (Exception ex) { throw new JSQLParserException(ex); } } private CCJSqlParserUtil(); static Statement parse(Reader statementReader); static Statement parse(String sql); static Node parseAST(String sql); static Statement parse(InputStream is); static Statement parse(InputStream is, String encoding); static Expression parseExpression(String expression); static Expression parseCondExpression(String condExpr); static Statements parseStatements(String sqls); }### Answer:
@Test public void testParseCondExpression() throws Exception { Expression result = CCJSqlParserUtil.parseCondExpression("a+b>5 and c<3"); assertEquals("a + b > 5 AND c < 3", result.toString()); } |
### Question:
Column extends ASTNodeAccessImpl implements Expression, MultiPartName { @Override public String toString() { return getName(true); } Column(); Column(Table table, String columnName); Column(String columnName); Table getTable(); void setTable(Table table); String getColumnName(); void setColumnName(String string); @Override String getFullyQualifiedName(); String getName(boolean aliases); @Override void accept(ExpressionVisitor expressionVisitor); @Override String toString(); }### Answer:
@Test public void testMissingTableAlias() { Table myTable = new Table("myTable"); myTable.setAlias(new Alias("tb")); Column myColumn = new Column(myTable, "myColumn"); assertEquals("tb.myColumn", myColumn.toString()); } |
### Question:
StringValue implements Expression { public String getValue() { return value; } StringValue(String escapedValue); String getValue(); String getNotExcapedValue(); void setValue(String string); @Override void accept(ExpressionVisitor expressionVisitor); @Override String toString(); }### Answer:
@Test public void testGetValue() { StringValue instance = new StringValue("'*'"); String expResult = "*"; String result = instance.getValue(); assertEquals(expResult, result); }
@Test public void testGetValue2_issue329() { StringValue instance = new StringValue("*"); String expResult = "*"; String result = instance.getValue(); assertEquals(expResult, result); } |
### Question:
StringValue implements Expression { public String getNotExcapedValue() { StringBuilder buffer = new StringBuilder(value); int index = 0; int deletesNum = 0; while ((index = value.indexOf("''", index)) != -1) { buffer.deleteCharAt(index - deletesNum); index += 2; deletesNum++; } return buffer.toString(); } StringValue(String escapedValue); String getValue(); String getNotExcapedValue(); void setValue(String string); @Override void accept(ExpressionVisitor expressionVisitor); @Override String toString(); }### Answer:
@Test public void testGetNotExcapedValue() { StringValue instance = new StringValue("'*''*'"); String expResult = "*'*"; String result = instance.getNotExcapedValue(); assertEquals(expResult, result); } |
### Question:
Elements extends ArrayList<Element> { public Elements remove() { for (Element element : this) { element.remove(); } return this; } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void remove() { Document doc = Jsoup.parse("<div><p>Hello <b>there</b></p> jsoup <p>now!</p></div>"); doc.outputSettings().prettyPrint(false); doc.select("p").remove(); assertEquals("<div> jsoup </div>", doc.body().html()); } |
### Question:
SignedExpression implements Expression { public char getSign() { return sign; } SignedExpression(char sign, Expression expression); char getSign(); final void setSign(char sign); Expression getExpression(); final void setExpression(Expression expression); @Override void accept(ExpressionVisitor expressionVisitor); @Override String toString(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testGetSign() throws JSQLParserException { new SignedExpression('*', CCJSqlParserUtil.parseExpression("a")); fail("must not work"); } |
### Question:
Java7Support { public static boolean isSymLink(File file) { try { Object path = toPath.invoke(file); Boolean result = (Boolean) isSymbolicLink.invoke(null, path); return result.booleanValue(); } catch (IllegalAccessException e) { throw new RuntimeException(e); } catch (InvocationTargetException e) { throw new RuntimeException(e); } } static boolean isSymLink(File file); static File readSymbolicLink(File symlink); static File createSymbolicLink(File symlink, File target); static void delete(File file); static boolean isAtLeastJava7(); }### Answer:
@Test public void testIsSymLink() throws Exception { File file = new File("."); if (Java7Support.isAtLeastJava7()) { assertFalse(Java7Support.isSymLink(file)); } } |
### Question:
EndianUtils { public static double readSwappedDouble(final byte[] data, final int offset) { return Double.longBitsToDouble( readSwappedLong( data, offset ) ); } EndianUtils(); static short swapShort(final short value); static int swapInteger(final int value); static long swapLong(final long value); static float swapFloat(final float value); static double swapDouble(final double value); static void writeSwappedShort(final byte[] data, final int offset, final short value); static short readSwappedShort(final byte[] data, final int offset); static int readSwappedUnsignedShort(final byte[] data, final int offset); static void writeSwappedInteger(final byte[] data, final int offset, final int value); static int readSwappedInteger(final byte[] data, final int offset); static long readSwappedUnsignedInteger(final byte[] data, final int offset); static void writeSwappedLong(final byte[] data, final int offset, final long value); static long readSwappedLong(final byte[] data, final int offset); static void writeSwappedFloat(final byte[] data, final int offset, final float value); static float readSwappedFloat(final byte[] data, final int offset); static void writeSwappedDouble(final byte[] data, final int offset, final double value); static double readSwappedDouble(final byte[] data, final int offset); static void writeSwappedShort(final OutputStream output, final short value); static short readSwappedShort(final InputStream input); static int readSwappedUnsignedShort(final InputStream input); static void writeSwappedInteger(final OutputStream output, final int value); static int readSwappedInteger(final InputStream input); static long readSwappedUnsignedInteger(final InputStream input); static void writeSwappedLong(final OutputStream output, final long value); static long readSwappedLong(final InputStream input); static void writeSwappedFloat(final OutputStream output, final float value); static float readSwappedFloat(final InputStream input); static void writeSwappedDouble(final OutputStream output, final double value); static double readSwappedDouble(final InputStream input); }### Answer:
@Test public void testEOFException() throws IOException { final ByteArrayInputStream input = new ByteArrayInputStream(new byte[] {}); try { EndianUtils.readSwappedDouble(input); fail("Expected EOFException"); } catch (final EOFException e) { } }
@Test public void testReadSwappedDouble() throws IOException { final byte[] bytes = new byte[] { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 }; final double d1 = Double.longBitsToDouble( 0x0102030405060708L ); final double d2 = EndianUtils.readSwappedDouble( bytes, 0 ); assertEquals( d1, d2, 0.0 ); final ByteArrayInputStream input = new ByteArrayInputStream(bytes); assertEquals( d1, EndianUtils.readSwappedDouble( input ), 0.0 ); } |
### Question:
EndianUtils { public static short swapShort(final short value) { return (short) ( ( ( ( value >> 0 ) & 0xff ) << 8 ) + ( ( ( value >> 8 ) & 0xff ) << 0 ) ); } EndianUtils(); static short swapShort(final short value); static int swapInteger(final int value); static long swapLong(final long value); static float swapFloat(final float value); static double swapDouble(final double value); static void writeSwappedShort(final byte[] data, final int offset, final short value); static short readSwappedShort(final byte[] data, final int offset); static int readSwappedUnsignedShort(final byte[] data, final int offset); static void writeSwappedInteger(final byte[] data, final int offset, final int value); static int readSwappedInteger(final byte[] data, final int offset); static long readSwappedUnsignedInteger(final byte[] data, final int offset); static void writeSwappedLong(final byte[] data, final int offset, final long value); static long readSwappedLong(final byte[] data, final int offset); static void writeSwappedFloat(final byte[] data, final int offset, final float value); static float readSwappedFloat(final byte[] data, final int offset); static void writeSwappedDouble(final byte[] data, final int offset, final double value); static double readSwappedDouble(final byte[] data, final int offset); static void writeSwappedShort(final OutputStream output, final short value); static short readSwappedShort(final InputStream input); static int readSwappedUnsignedShort(final InputStream input); static void writeSwappedInteger(final OutputStream output, final int value); static int readSwappedInteger(final InputStream input); static long readSwappedUnsignedInteger(final InputStream input); static void writeSwappedLong(final OutputStream output, final long value); static long readSwappedLong(final InputStream input); static void writeSwappedFloat(final OutputStream output, final float value); static float readSwappedFloat(final InputStream input); static void writeSwappedDouble(final OutputStream output, final double value); static double readSwappedDouble(final InputStream input); }### Answer:
@Test public void testSwapShort() { assertEquals( (short) 0, EndianUtils.swapShort( (short) 0 ) ); assertEquals( (short) 0x0201, EndianUtils.swapShort( (short) 0x0102 ) ); assertEquals( (short) 0xffff, EndianUtils.swapShort( (short) 0xffff ) ); assertEquals( (short) 0x0102, EndianUtils.swapShort( (short) 0x0201 ) ); } |
### Question:
EndianUtils { public static int swapInteger(final int value) { return ( ( ( value >> 0 ) & 0xff ) << 24 ) + ( ( ( value >> 8 ) & 0xff ) << 16 ) + ( ( ( value >> 16 ) & 0xff ) << 8 ) + ( ( ( value >> 24 ) & 0xff ) << 0 ); } EndianUtils(); static short swapShort(final short value); static int swapInteger(final int value); static long swapLong(final long value); static float swapFloat(final float value); static double swapDouble(final double value); static void writeSwappedShort(final byte[] data, final int offset, final short value); static short readSwappedShort(final byte[] data, final int offset); static int readSwappedUnsignedShort(final byte[] data, final int offset); static void writeSwappedInteger(final byte[] data, final int offset, final int value); static int readSwappedInteger(final byte[] data, final int offset); static long readSwappedUnsignedInteger(final byte[] data, final int offset); static void writeSwappedLong(final byte[] data, final int offset, final long value); static long readSwappedLong(final byte[] data, final int offset); static void writeSwappedFloat(final byte[] data, final int offset, final float value); static float readSwappedFloat(final byte[] data, final int offset); static void writeSwappedDouble(final byte[] data, final int offset, final double value); static double readSwappedDouble(final byte[] data, final int offset); static void writeSwappedShort(final OutputStream output, final short value); static short readSwappedShort(final InputStream input); static int readSwappedUnsignedShort(final InputStream input); static void writeSwappedInteger(final OutputStream output, final int value); static int readSwappedInteger(final InputStream input); static long readSwappedUnsignedInteger(final InputStream input); static void writeSwappedLong(final OutputStream output, final long value); static long readSwappedLong(final InputStream input); static void writeSwappedFloat(final OutputStream output, final float value); static float readSwappedFloat(final InputStream input); static void writeSwappedDouble(final OutputStream output, final double value); static double readSwappedDouble(final InputStream input); }### Answer:
@Test public void testSwapInteger() { assertEquals( 0, EndianUtils.swapInteger( 0 ) ); assertEquals( 0x04030201, EndianUtils.swapInteger( 0x01020304 ) ); assertEquals( 0x01000000, EndianUtils.swapInteger( 0x00000001 ) ); assertEquals( 0x00000001, EndianUtils.swapInteger( 0x01000000 ) ); assertEquals( 0x11111111, EndianUtils.swapInteger( 0x11111111 ) ); assertEquals( 0xabcdef10, EndianUtils.swapInteger( 0x10efcdab ) ); assertEquals( 0xab, EndianUtils.swapInteger( 0xab000000 ) ); } |
### Question:
EndianUtils { public static long swapLong(final long value) { return ( ( ( value >> 0 ) & 0xff ) << 56 ) + ( ( ( value >> 8 ) & 0xff ) << 48 ) + ( ( ( value >> 16 ) & 0xff ) << 40 ) + ( ( ( value >> 24 ) & 0xff ) << 32 ) + ( ( ( value >> 32 ) & 0xff ) << 24 ) + ( ( ( value >> 40 ) & 0xff ) << 16 ) + ( ( ( value >> 48 ) & 0xff ) << 8 ) + ( ( ( value >> 56 ) & 0xff ) << 0 ); } EndianUtils(); static short swapShort(final short value); static int swapInteger(final int value); static long swapLong(final long value); static float swapFloat(final float value); static double swapDouble(final double value); static void writeSwappedShort(final byte[] data, final int offset, final short value); static short readSwappedShort(final byte[] data, final int offset); static int readSwappedUnsignedShort(final byte[] data, final int offset); static void writeSwappedInteger(final byte[] data, final int offset, final int value); static int readSwappedInteger(final byte[] data, final int offset); static long readSwappedUnsignedInteger(final byte[] data, final int offset); static void writeSwappedLong(final byte[] data, final int offset, final long value); static long readSwappedLong(final byte[] data, final int offset); static void writeSwappedFloat(final byte[] data, final int offset, final float value); static float readSwappedFloat(final byte[] data, final int offset); static void writeSwappedDouble(final byte[] data, final int offset, final double value); static double readSwappedDouble(final byte[] data, final int offset); static void writeSwappedShort(final OutputStream output, final short value); static short readSwappedShort(final InputStream input); static int readSwappedUnsignedShort(final InputStream input); static void writeSwappedInteger(final OutputStream output, final int value); static int readSwappedInteger(final InputStream input); static long readSwappedUnsignedInteger(final InputStream input); static void writeSwappedLong(final OutputStream output, final long value); static long readSwappedLong(final InputStream input); static void writeSwappedFloat(final OutputStream output, final float value); static float readSwappedFloat(final InputStream input); static void writeSwappedDouble(final OutputStream output, final double value); static double readSwappedDouble(final InputStream input); }### Answer:
@Test public void testSwapLong() { assertEquals( 0, EndianUtils.swapLong( 0 ) ); assertEquals( 0x0807060504030201L, EndianUtils.swapLong( 0x0102030405060708L ) ); assertEquals( 0xffffffffffffffffL, EndianUtils.swapLong( 0xffffffffffffffffL ) ); assertEquals( 0xab, EndianUtils.swapLong( 0xab00000000000000L ) ); } |
### Question:
EndianUtils { public static float swapFloat(final float value) { return Float.intBitsToFloat( swapInteger( Float.floatToIntBits( value ) ) ); } EndianUtils(); static short swapShort(final short value); static int swapInteger(final int value); static long swapLong(final long value); static float swapFloat(final float value); static double swapDouble(final double value); static void writeSwappedShort(final byte[] data, final int offset, final short value); static short readSwappedShort(final byte[] data, final int offset); static int readSwappedUnsignedShort(final byte[] data, final int offset); static void writeSwappedInteger(final byte[] data, final int offset, final int value); static int readSwappedInteger(final byte[] data, final int offset); static long readSwappedUnsignedInteger(final byte[] data, final int offset); static void writeSwappedLong(final byte[] data, final int offset, final long value); static long readSwappedLong(final byte[] data, final int offset); static void writeSwappedFloat(final byte[] data, final int offset, final float value); static float readSwappedFloat(final byte[] data, final int offset); static void writeSwappedDouble(final byte[] data, final int offset, final double value); static double readSwappedDouble(final byte[] data, final int offset); static void writeSwappedShort(final OutputStream output, final short value); static short readSwappedShort(final InputStream input); static int readSwappedUnsignedShort(final InputStream input); static void writeSwappedInteger(final OutputStream output, final int value); static int readSwappedInteger(final InputStream input); static long readSwappedUnsignedInteger(final InputStream input); static void writeSwappedLong(final OutputStream output, final long value); static long readSwappedLong(final InputStream input); static void writeSwappedFloat(final OutputStream output, final float value); static float readSwappedFloat(final InputStream input); static void writeSwappedDouble(final OutputStream output, final double value); static double readSwappedDouble(final InputStream input); }### Answer:
@Test public void testSwapFloat() { assertEquals( 0.0f, EndianUtils.swapFloat( 0.0f ), 0.0 ); final float f1 = Float.intBitsToFloat( 0x01020304 ); final float f2 = Float.intBitsToFloat( 0x04030201 ); assertEquals( f2, EndianUtils.swapFloat( f1 ), 0.0 ); } |
### Question:
EndianUtils { public static double swapDouble(final double value) { return Double.longBitsToDouble( swapLong( Double.doubleToLongBits( value ) ) ); } EndianUtils(); static short swapShort(final short value); static int swapInteger(final int value); static long swapLong(final long value); static float swapFloat(final float value); static double swapDouble(final double value); static void writeSwappedShort(final byte[] data, final int offset, final short value); static short readSwappedShort(final byte[] data, final int offset); static int readSwappedUnsignedShort(final byte[] data, final int offset); static void writeSwappedInteger(final byte[] data, final int offset, final int value); static int readSwappedInteger(final byte[] data, final int offset); static long readSwappedUnsignedInteger(final byte[] data, final int offset); static void writeSwappedLong(final byte[] data, final int offset, final long value); static long readSwappedLong(final byte[] data, final int offset); static void writeSwappedFloat(final byte[] data, final int offset, final float value); static float readSwappedFloat(final byte[] data, final int offset); static void writeSwappedDouble(final byte[] data, final int offset, final double value); static double readSwappedDouble(final byte[] data, final int offset); static void writeSwappedShort(final OutputStream output, final short value); static short readSwappedShort(final InputStream input); static int readSwappedUnsignedShort(final InputStream input); static void writeSwappedInteger(final OutputStream output, final int value); static int readSwappedInteger(final InputStream input); static long readSwappedUnsignedInteger(final InputStream input); static void writeSwappedLong(final OutputStream output, final long value); static long readSwappedLong(final InputStream input); static void writeSwappedFloat(final OutputStream output, final float value); static float readSwappedFloat(final InputStream input); static void writeSwappedDouble(final OutputStream output, final double value); static double readSwappedDouble(final InputStream input); }### Answer:
@Test public void testSwapDouble() { assertEquals( 0.0, EndianUtils.swapDouble( 0.0 ), 0.0 ); final double d1 = Double.longBitsToDouble( 0x0102030405060708L ); final double d2 = Double.longBitsToDouble( 0x0807060504030201L ); assertEquals( d2, EndianUtils.swapDouble( d1 ), 0.0 ); } |
### Question:
Elements extends ArrayList<Element> { public Elements eq(int index) { return size() > index ? new Elements(get(index)) : new Elements(); } Elements(); Elements(int initialCapacity); Elements(Collection<Element> elements); Elements(List<Element> elements); Elements(Element... elements); @Override Elements clone(); String attr(String attributeKey); boolean hasAttr(String attributeKey); List<String> eachAttr(String attributeKey); Elements attr(String attributeKey, String attributeValue); Elements removeAttr(String attributeKey); Elements addClass(String className); Elements removeClass(String className); Elements toggleClass(String className); boolean hasClass(String className); String val(); Elements val(String value); String text(); boolean hasText(); List<String> eachText(); String html(); String outerHtml(); @Override String toString(); Elements tagName(String tagName); Elements html(String html); Elements prepend(String html); Elements append(String html); Elements before(String html); Elements after(String html); Elements wrap(String html); Elements unwrap(); Elements empty(); Elements remove(); Elements select(String query); Elements not(String query); Elements eq(int index); boolean is(String query); Elements next(); Elements next(String query); Elements nextAll(); Elements nextAll(String query); Elements prev(); Elements prev(String query); Elements prevAll(); Elements prevAll(String query); Elements parents(); Element first(); Element last(); Elements traverse(NodeVisitor nodeVisitor); List<FormElement> forms(); }### Answer:
@Test public void eq() { String h = "<p>Hello<p>there<p>world"; Document doc = Jsoup.parse(h); assertEquals("there", doc.select("p").eq(1).text()); assertEquals("there", doc.select("p").get(1).text()); } |
### Question:
EndianUtils { public static short readSwappedShort(final byte[] data, final int offset) { return (short)( ( ( data[ offset + 0 ] & 0xff ) << 0 ) + ( ( data[ offset + 1 ] & 0xff ) << 8 ) ); } EndianUtils(); static short swapShort(final short value); static int swapInteger(final int value); static long swapLong(final long value); static float swapFloat(final float value); static double swapDouble(final double value); static void writeSwappedShort(final byte[] data, final int offset, final short value); static short readSwappedShort(final byte[] data, final int offset); static int readSwappedUnsignedShort(final byte[] data, final int offset); static void writeSwappedInteger(final byte[] data, final int offset, final int value); static int readSwappedInteger(final byte[] data, final int offset); static long readSwappedUnsignedInteger(final byte[] data, final int offset); static void writeSwappedLong(final byte[] data, final int offset, final long value); static long readSwappedLong(final byte[] data, final int offset); static void writeSwappedFloat(final byte[] data, final int offset, final float value); static float readSwappedFloat(final byte[] data, final int offset); static void writeSwappedDouble(final byte[] data, final int offset, final double value); static double readSwappedDouble(final byte[] data, final int offset); static void writeSwappedShort(final OutputStream output, final short value); static short readSwappedShort(final InputStream input); static int readSwappedUnsignedShort(final InputStream input); static void writeSwappedInteger(final OutputStream output, final int value); static int readSwappedInteger(final InputStream input); static long readSwappedUnsignedInteger(final InputStream input); static void writeSwappedLong(final OutputStream output, final long value); static long readSwappedLong(final InputStream input); static void writeSwappedFloat(final OutputStream output, final float value); static float readSwappedFloat(final InputStream input); static void writeSwappedDouble(final OutputStream output, final double value); static double readSwappedDouble(final InputStream input); }### Answer:
@Test public void testReadSwappedShort() throws IOException { final byte[] bytes = new byte[] { 0x02, 0x01 }; assertEquals( 0x0102, EndianUtils.readSwappedShort( bytes, 0 ) ); final ByteArrayInputStream input = new ByteArrayInputStream(bytes); assertEquals( 0x0102, EndianUtils.readSwappedShort( input ) ); } |
### Question:
EndianUtils { public static void writeSwappedShort(final byte[] data, final int offset, final short value) { data[ offset + 0 ] = (byte)( ( value >> 0 ) & 0xff ); data[ offset + 1 ] = (byte)( ( value >> 8 ) & 0xff ); } EndianUtils(); static short swapShort(final short value); static int swapInteger(final int value); static long swapLong(final long value); static float swapFloat(final float value); static double swapDouble(final double value); static void writeSwappedShort(final byte[] data, final int offset, final short value); static short readSwappedShort(final byte[] data, final int offset); static int readSwappedUnsignedShort(final byte[] data, final int offset); static void writeSwappedInteger(final byte[] data, final int offset, final int value); static int readSwappedInteger(final byte[] data, final int offset); static long readSwappedUnsignedInteger(final byte[] data, final int offset); static void writeSwappedLong(final byte[] data, final int offset, final long value); static long readSwappedLong(final byte[] data, final int offset); static void writeSwappedFloat(final byte[] data, final int offset, final float value); static float readSwappedFloat(final byte[] data, final int offset); static void writeSwappedDouble(final byte[] data, final int offset, final double value); static double readSwappedDouble(final byte[] data, final int offset); static void writeSwappedShort(final OutputStream output, final short value); static short readSwappedShort(final InputStream input); static int readSwappedUnsignedShort(final InputStream input); static void writeSwappedInteger(final OutputStream output, final int value); static int readSwappedInteger(final InputStream input); static long readSwappedUnsignedInteger(final InputStream input); static void writeSwappedLong(final OutputStream output, final long value); static long readSwappedLong(final InputStream input); static void writeSwappedFloat(final OutputStream output, final float value); static float readSwappedFloat(final InputStream input); static void writeSwappedDouble(final OutputStream output, final double value); static double readSwappedDouble(final InputStream input); }### Answer:
@Test public void testWriteSwappedShort() throws IOException { byte[] bytes = new byte[2]; EndianUtils.writeSwappedShort( bytes, 0, (short) 0x0102 ); assertEquals( 0x02, bytes[0] ); assertEquals( 0x01, bytes[1] ); final ByteArrayOutputStream baos = new ByteArrayOutputStream(2); EndianUtils.writeSwappedShort( baos, (short) 0x0102 ); bytes = baos.toByteArray(); assertEquals( 0x02, bytes[0] ); assertEquals( 0x01, bytes[1] ); } |
### Question:
EndianUtils { public static int readSwappedUnsignedShort(final byte[] data, final int offset) { return ( ( ( data[ offset + 0 ] & 0xff ) << 0 ) + ( ( data[ offset + 1 ] & 0xff ) << 8 ) ); } EndianUtils(); static short swapShort(final short value); static int swapInteger(final int value); static long swapLong(final long value); static float swapFloat(final float value); static double swapDouble(final double value); static void writeSwappedShort(final byte[] data, final int offset, final short value); static short readSwappedShort(final byte[] data, final int offset); static int readSwappedUnsignedShort(final byte[] data, final int offset); static void writeSwappedInteger(final byte[] data, final int offset, final int value); static int readSwappedInteger(final byte[] data, final int offset); static long readSwappedUnsignedInteger(final byte[] data, final int offset); static void writeSwappedLong(final byte[] data, final int offset, final long value); static long readSwappedLong(final byte[] data, final int offset); static void writeSwappedFloat(final byte[] data, final int offset, final float value); static float readSwappedFloat(final byte[] data, final int offset); static void writeSwappedDouble(final byte[] data, final int offset, final double value); static double readSwappedDouble(final byte[] data, final int offset); static void writeSwappedShort(final OutputStream output, final short value); static short readSwappedShort(final InputStream input); static int readSwappedUnsignedShort(final InputStream input); static void writeSwappedInteger(final OutputStream output, final int value); static int readSwappedInteger(final InputStream input); static long readSwappedUnsignedInteger(final InputStream input); static void writeSwappedLong(final OutputStream output, final long value); static long readSwappedLong(final InputStream input); static void writeSwappedFloat(final OutputStream output, final float value); static float readSwappedFloat(final InputStream input); static void writeSwappedDouble(final OutputStream output, final double value); static double readSwappedDouble(final InputStream input); }### Answer:
@Test public void testReadSwappedUnsignedShort() throws IOException { final byte[] bytes = new byte[] { 0x02, 0x01 }; assertEquals( 0x00000102, EndianUtils.readSwappedUnsignedShort( bytes, 0 ) ); final ByteArrayInputStream input = new ByteArrayInputStream(bytes); assertEquals( 0x00000102, EndianUtils.readSwappedUnsignedShort( input ) ); } |
### Question:
EndianUtils { public static int readSwappedInteger(final byte[] data, final int offset) { return ( ( ( data[ offset + 0 ] & 0xff ) << 0 ) + ( ( data[ offset + 1 ] & 0xff ) << 8 ) + ( ( data[ offset + 2 ] & 0xff ) << 16 ) + ( ( data[ offset + 3 ] & 0xff ) << 24 ) ); } EndianUtils(); static short swapShort(final short value); static int swapInteger(final int value); static long swapLong(final long value); static float swapFloat(final float value); static double swapDouble(final double value); static void writeSwappedShort(final byte[] data, final int offset, final short value); static short readSwappedShort(final byte[] data, final int offset); static int readSwappedUnsignedShort(final byte[] data, final int offset); static void writeSwappedInteger(final byte[] data, final int offset, final int value); static int readSwappedInteger(final byte[] data, final int offset); static long readSwappedUnsignedInteger(final byte[] data, final int offset); static void writeSwappedLong(final byte[] data, final int offset, final long value); static long readSwappedLong(final byte[] data, final int offset); static void writeSwappedFloat(final byte[] data, final int offset, final float value); static float readSwappedFloat(final byte[] data, final int offset); static void writeSwappedDouble(final byte[] data, final int offset, final double value); static double readSwappedDouble(final byte[] data, final int offset); static void writeSwappedShort(final OutputStream output, final short value); static short readSwappedShort(final InputStream input); static int readSwappedUnsignedShort(final InputStream input); static void writeSwappedInteger(final OutputStream output, final int value); static int readSwappedInteger(final InputStream input); static long readSwappedUnsignedInteger(final InputStream input); static void writeSwappedLong(final OutputStream output, final long value); static long readSwappedLong(final InputStream input); static void writeSwappedFloat(final OutputStream output, final float value); static float readSwappedFloat(final InputStream input); static void writeSwappedDouble(final OutputStream output, final double value); static double readSwappedDouble(final InputStream input); }### Answer:
@Test public void testReadSwappedInteger() throws IOException { final byte[] bytes = new byte[] { 0x04, 0x03, 0x02, 0x01 }; assertEquals( 0x01020304, EndianUtils.readSwappedInteger( bytes, 0 ) ); final ByteArrayInputStream input = new ByteArrayInputStream(bytes); assertEquals( 0x01020304, EndianUtils.readSwappedInteger( input ) ); } |
### Question:
EndianUtils { public static void writeSwappedInteger(final byte[] data, final int offset, final int value) { data[ offset + 0 ] = (byte)( ( value >> 0 ) & 0xff ); data[ offset + 1 ] = (byte)( ( value >> 8 ) & 0xff ); data[ offset + 2 ] = (byte)( ( value >> 16 ) & 0xff ); data[ offset + 3 ] = (byte)( ( value >> 24 ) & 0xff ); } EndianUtils(); static short swapShort(final short value); static int swapInteger(final int value); static long swapLong(final long value); static float swapFloat(final float value); static double swapDouble(final double value); static void writeSwappedShort(final byte[] data, final int offset, final short value); static short readSwappedShort(final byte[] data, final int offset); static int readSwappedUnsignedShort(final byte[] data, final int offset); static void writeSwappedInteger(final byte[] data, final int offset, final int value); static int readSwappedInteger(final byte[] data, final int offset); static long readSwappedUnsignedInteger(final byte[] data, final int offset); static void writeSwappedLong(final byte[] data, final int offset, final long value); static long readSwappedLong(final byte[] data, final int offset); static void writeSwappedFloat(final byte[] data, final int offset, final float value); static float readSwappedFloat(final byte[] data, final int offset); static void writeSwappedDouble(final byte[] data, final int offset, final double value); static double readSwappedDouble(final byte[] data, final int offset); static void writeSwappedShort(final OutputStream output, final short value); static short readSwappedShort(final InputStream input); static int readSwappedUnsignedShort(final InputStream input); static void writeSwappedInteger(final OutputStream output, final int value); static int readSwappedInteger(final InputStream input); static long readSwappedUnsignedInteger(final InputStream input); static void writeSwappedLong(final OutputStream output, final long value); static long readSwappedLong(final InputStream input); static void writeSwappedFloat(final OutputStream output, final float value); static float readSwappedFloat(final InputStream input); static void writeSwappedDouble(final OutputStream output, final double value); static double readSwappedDouble(final InputStream input); }### Answer:
@Test public void testWriteSwappedInteger() throws IOException { byte[] bytes = new byte[4]; EndianUtils.writeSwappedInteger( bytes, 0, 0x01020304 ); assertEquals( 0x04, bytes[0] ); assertEquals( 0x03, bytes[1] ); assertEquals( 0x02, bytes[2] ); assertEquals( 0x01, bytes[3] ); final ByteArrayOutputStream baos = new ByteArrayOutputStream(4); EndianUtils.writeSwappedInteger( baos, 0x01020304 ); bytes = baos.toByteArray(); assertEquals( 0x04, bytes[0] ); assertEquals( 0x03, bytes[1] ); assertEquals( 0x02, bytes[2] ); assertEquals( 0x01, bytes[3] ); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.