Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: BeanUtil { public static List<PropertyMeta> fetchPropertyMetas(Class<?> clazz) { return cache.get(clazz); } static List<PropertyMeta> fetchPropertyMetas(Class<?> clazz); }### Answer: @Test public void fetchPropertyMetas() throws Exception { Set<PropertyMeta> pms = Sets.newHashSet(BeanUtil.fetchPropertyMetas(A.class)); Set<PropertyMeta> set = Sets.newHashSet(); set.add(getPropertyMeta(A.class, "id", int.class)); set.add(getPropertyMeta(A.class, "uid", int.class)); set.add(getPropertyMeta(A.class, "name", String.class)); assertThat(pms, equalTo(set)); }
### Question: InvocationContextFactory { public InvocationContext newInvocationContext(Object[] values) { InvocationContext context = DefaultInvocationContext.create(); for (int i = 0; i < values.length; i++) { String parameterName = parameterContext.getParameterNameByPosition(i); context.addParameter(parameterName, values[i]); } return context; } private InvocationContextFactory(ParameterContext parameterContext); static InvocationContextFactory create(ParameterContext parameterContext); InvocationContext newInvocationContext(Object[] values); }### Answer: @Test public void testNewInvocationContext() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "name"); ParameterDescriptor p1 = ParameterDescriptor.create(1, int.class, empty, "id"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext paramCtx = DefaultParameterContext.create(pds); InvocationContextFactory factory = InvocationContextFactory.create(paramCtx); InvocationContext invCtx = factory.newInvocationContext(new Object[]{"ash", 9527}); BindingParameterInvoker nameInvoker = FunctionalBindingParameterInvoker.create(String.class, BindingParameter.create("name", "", null)); BindingParameterInvoker idInvoker = FunctionalBindingParameterInvoker.create(String.class, BindingParameter.create("id", "", null)); assertThat(invCtx.getNullableBindingValue(nameInvoker), equalTo((Object) "ash")); assertThat(invCtx.getNullableBindingValue(idInvoker), equalTo((Object) 9527)); }
### Question: LruObjectCache implements ObjectCache { @Override public <T> void clear(Class<T> clazz) { Map<Object, Object> objectMap = getMapForClass(clazz); if (objectMap != null) { objectMap.clear(); } } LruObjectCache(int capacity); @Override synchronized void registerClass(Class<T> clazz); @Override T get(Class<T> clazz, ID id); @Override void put(Class<T> clazz, ID id, T data); @Override void clear(Class<T> clazz); @Override void clearAll(); @Override void remove(Class<T> clazz, ID id); @Override T updateId(Class<T> clazz, ID oldId, ID newId); @Override int size(Class<T> clazz); @Override int sizeAll(); }### Answer: @Test public void testClear() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); LruObjectCache cache = new LruObjectCache(2); dao.setObjectCache(cache); Foo foo = new Foo(); int val = 12312321; foo.val = val; assertEquals(1, dao.create(foo)); assertEquals(1, cache.size(Foo.class)); Foo result = dao.queryForId(foo.id); assertSame(foo, result); dao.clearObjectCache(); result = dao.queryForId(foo.id); assertNotSame(foo, result); }
### Question: DaoManager { public synchronized static <D extends Dao<T, ?>, T> D lookupDao(ConnectionSource connectionSource, Class<T> clazz) { if (connectionSource == null) { throw new IllegalArgumentException("connectionSource argument cannot be null"); } ClassConnectionSource key = new ClassConnectionSource(connectionSource, clazz); Dao<?, ?> dao = lookupDao(key); @SuppressWarnings("unchecked") D castDao = (D) dao; return castDao; } synchronized static D createDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D lookupDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D createDao(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); synchronized static D lookupDao(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); static synchronized void registerDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void unregisterDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void registerDaoWithTableConfig(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void clearCache(); static synchronized void clearDaoCache(); static synchronized void addCachedDatabaseConfigs(Collection<DatabaseTableConfig<?>> configs); }### Answer: @Test(expected = IllegalArgumentException.class) public void testLookupDaoNull() { DaoManager.lookupDao(null, Foo.class); } @Test public void testLookupDaoUnknown() { assertNull(DaoManager.lookupDao(connectionSource, getClass())); } @Test(expected = IllegalArgumentException.class) public void testLookupDaoTableNull() { DaoManager.lookupDao(null, new DatabaseTableConfig<Foo>()); } @Test public void testLookupTableDaoUnknown() { assertNull(DaoManager.lookupDao(connectionSource, new DatabaseTableConfig<DaoManagerTest>(DaoManagerTest.class, new ArrayList<DatabaseFieldConfig>()))); }
### Question: DaoManager { public static synchronized void registerDao(ConnectionSource connectionSource, Dao<?, ?> dao) { if (connectionSource == null) { throw new IllegalArgumentException("connectionSource argument cannot be null"); } addDaoToClassMap(new ClassConnectionSource(connectionSource, dao.getDataClass()), dao); } synchronized static D createDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D lookupDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D createDao(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); synchronized static D lookupDao(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); static synchronized void registerDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void unregisterDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void registerDaoWithTableConfig(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void clearCache(); static synchronized void clearDaoCache(); static synchronized void addCachedDatabaseConfigs(Collection<DatabaseTableConfig<?>> configs); }### Answer: @Test public void testRegisterDao() throws Exception { Dao<RegisterClass, Void> dao = DaoManager.lookupDao(connectionSource, RegisterClass.class); assertNull(dao); Dao<? extends RegisterClass, Object> daoImpl = BaseDaoImpl.createDao(connectionSource, RegisterClass.class); DaoManager.registerDao(connectionSource, daoImpl); dao = DaoManager.lookupDao(connectionSource, RegisterClass.class); assertSame(daoImpl, dao); } @Test(expected = IllegalArgumentException.class) public void testRegisterNull() { DaoManager.registerDao(null, null); }
### Question: DefaultInvocationContext implements InvocationContext { @Override public Object getBindingValue(BindingParameterInvoker invoker) { Object value = getNullableBindingValue(invoker); if (value == null) { throw new BindingException("Parameter '" + invoker.getBindingParameter() + "' need a non-null value"); } return value; } private DefaultInvocationContext(); static DefaultInvocationContext create(); @Override void addParameter(String parameterName, Object parameterValue); @Override Object getBindingValue(BindingParameterInvoker invoker); @Override @Nullable Object getNullableBindingValue(BindingParameterInvoker invoker); @Override void setBindingValue(BindingParameterInvoker invoker, Object value); @Override @Nullable String getGlobalTable(); @Override void setGlobalTable(String globalTable); @Override void writeToSqlBuffer(String str); @Override void appendToArgs(Object obj, TypeHandler<?> typeHandler); @Override BoundSql getBoundSql(); @Override List<Object> getParameterValues(); }### Answer: @Test public void testGetBindingValue() throws Exception { DefaultInvocationContext ctx = DefaultInvocationContext.create(); ctx.addParameter("userId", 9527); BindingParameterInvoker userIdInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("userId", "", null)); assertThat(ctx.getBindingValue(userIdInvoker), equalTo((Object) 9527)); }
### Question: DefaultInvocationContext implements InvocationContext { @Override public void setBindingValue(BindingParameterInvoker invoker, Object value) { String key = getCacheKey(invoker); cache.put(key, value); } private DefaultInvocationContext(); static DefaultInvocationContext create(); @Override void addParameter(String parameterName, Object parameterValue); @Override Object getBindingValue(BindingParameterInvoker invoker); @Override @Nullable Object getNullableBindingValue(BindingParameterInvoker invoker); @Override void setBindingValue(BindingParameterInvoker invoker, Object value); @Override @Nullable String getGlobalTable(); @Override void setGlobalTable(String globalTable); @Override void writeToSqlBuffer(String str); @Override void appendToArgs(Object obj, TypeHandler<?> typeHandler); @Override BoundSql getBoundSql(); @Override List<Object> getParameterValues(); }### Answer: @Test public void testSetBindingValue() throws Exception { DefaultInvocationContext ctx = DefaultInvocationContext.create(); ctx.addParameter("userId", 9527); BindingParameterInvoker userIdInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("userId", "", null)); assertThat(ctx.getBindingValue(userIdInvoker), equalTo((Object) 9527)); ctx.setBindingValue(userIdInvoker, 666); assertThat(ctx.getBindingValue(userIdInvoker), equalTo((Object) 666)); }
### Question: DefaultParameterContext implements ParameterContext { @Override public String getParameterNameByPosition(int position) { String name = positionToNameMap.get(position); if (name == null) { throw new IllegalStateException("parameter name can not be found by position [" + position + "]"); } return name; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }### Answer: @Test public void testGetParameterNameByPosition() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "param1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, int.class, empty, "param2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); assertThat(ctx.getParameterNameByPosition(0), equalTo("param1")); assertThat(ctx.getParameterNameByPosition(1), equalTo("param2")); }
### Question: DefaultParameterContext implements ParameterContext { @Override public BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter) { String parameterName = bindingParameter.getParameterName(); Type type = nameToTypeMap.get(parameterName); if (type == null) { throw new BindingException("Parameter '" + BindingParameter.create(bindingParameter.getParameterName(), "", null) + "' not found, available root parameters are " + transToBindingParameters(nameToTypeMap.keySet())); } return FunctionalBindingParameterInvoker.create(type, bindingParameter); } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }### Answer: @Test public void testGetBindingParameterInvoker() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, User.class, empty, "2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); checkBindingParameterInvoker(ctx, "1", "", String.class); checkBindingParameterInvoker(ctx, "2", "userBag.item.itemId", int.class); checkBindingParameterInvoker(ctx, "2", "userBag.item.objItemId", Integer.class); checkBindingParameterInvoker(ctx, "2", "userId", String.class); }
### Question: DefaultParameterContext implements ParameterContext { @Override public List<ParameterDescriptor> getParameterDescriptors() { return parameterDescriptors; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }### Answer: @Test public void testGetParameterDescriptors() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, User.class, empty, "2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); assertThat(ctx.getParameterDescriptors(), equalTo(pds)); }
### Question: BaseConnectionSource implements ConnectionSource { @Override public DatabaseConnection getSpecialConnection(String tableName) { NestedConnection currentSaved = specialConnection.get(); if (currentSaved == null) { return null; } else { return currentSaved.connection; } } @Override DatabaseConnection getSpecialConnection(String tableName); }### Answer: @Test public void testNestedSave() throws Exception { OurConnectionSource cs = new OurConnectionSource(); DatabaseConnection conn = cs.getReadOnlyConnection(null); cs.saveSpecialConnection(conn); cs.saveSpecialConnection(conn); cs.clearSpecialConnection(conn); assertEquals(conn, cs.getSpecialConnection(null)); cs.close(); }
### Question: DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isAutoCommitSupported() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommitSupported(); } } 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 testIsAutoCommitSupported() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean supported = true; expect(conn.isAutoCommitSupported()).andReturn(supported); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(supported, proxy.isAutoCommitSupported()); proxy.close(); verify(conn); }
### Question: DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isAutoCommit() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommit(); } } 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 testIsAutoCommit() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean autoCommit = false; expect(conn.isAutoCommit()).andReturn(autoCommit); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(autoCommit, proxy.isAutoCommit()); proxy.close(); verify(conn); }
### Question: DatabaseConnectionProxy implements DatabaseConnection { @Override public void setAutoCommit(boolean autoCommit) throws SQLException { if (proxy != null) { proxy.setAutoCommit(autoCommit); } } 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 testSetAutoCommit() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean autoCommit = false; conn.setAutoCommit(autoCommit); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.setAutoCommit(autoCommit); proxy.close(); verify(conn); }
### Question: DatabaseConnectionProxy implements DatabaseConnection { @Override public Savepoint setSavePoint(String name) throws SQLException { if (proxy == null) { return null; } else { return proxy.setSavePoint(name); } } 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 testSetSavePoint() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); String name = "savepoint"; expect(conn.setSavePoint(name)).andReturn(null); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.setSavePoint(name); proxy.close(); verify(conn); }
### Question: DatabaseConnectionProxy implements DatabaseConnection { @Override public void commit(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.commit(savePoint); } } 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 testCommit() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); conn.commit(null); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.commit(null); proxy.close(); verify(conn); }
### Question: DatabaseConnectionProxy implements DatabaseConnection { @Override public void rollback(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.rollback(savePoint); } } 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 testRollback() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); conn.rollback(null); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.rollback(null); proxy.close(); verify(conn); }
### Question: DatabaseConnectionProxy implements DatabaseConnection { @Override public int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder) throws SQLException { if (proxy == null) { return 0; } else { return proxy.insert(statement, args, argfieldTypes, keyHolder); } } 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 testInsert() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); String statement = "insert bar"; int result = 13712321; expect(conn.insert(statement, null, null, null)).andReturn(result); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(result, proxy.insert(statement, null, null, null)); proxy.close(); verify(conn); }
### 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: 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/mangoDao.class")); assertThat(mc.locationPatterns.get(1), is("classpath:org/jfaster/mangoDAO.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/jfasterDao.class")); assertThat(mc.locationPatterns.get(5), is("classpath:org/jfasterDAO.class")); }
### 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: 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 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: 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: 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: 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: 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: 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: 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: Elements extends ArrayList<Element> { public boolean is(String query) { Evaluator eval = QueryParser.parse(query); for (Element e : this) { if (e.is(eval)) 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 is() { String h = "<p>Hello<p title=foo>there<p>world"; Document doc = Jsoup.parse(h); Elements ps = doc.select("p"); assertTrue(ps.is("[title=foo]")); assertFalse(ps.is("[title=bar]")); }
### Question: FullClassNameMatcher implements ClassNameMatcher { @Override public boolean matches(String className) { return classesSet.contains(className); } FullClassNameMatcher(String... classes); @Override boolean matches(String className); }### Answer: @Test public void noNames() throws Exception { final FullClassNameMatcher m = new FullClassNameMatcher(); assertFalse(m.matches(Integer.class.getName())); } @Test public void withNames() throws Exception { final FullClassNameMatcher m = new FullClassNameMatcher(NAMES_ARRAY); assertTrue(m.matches(Integer.class.getName())); assertFalse(m.matches(String.class.getName())); }
### Question: WildcardClassNameMatcher implements ClassNameMatcher { @Override public boolean matches(String className) { return FilenameUtils.wildcardMatch(className, pattern); } WildcardClassNameMatcher(String pattern); @Override boolean matches(String className); }### Answer: @Test public void noPattern() { ClassNameMatcher ca = new WildcardClassNameMatcher("org.foo"); assertTrue(ca.matches("org.foo")); assertFalse(ca.matches("org.foo.and.more")); assertFalse(ca.matches("org_foo")); } @Test public void star() { ClassNameMatcher ca = new WildcardClassNameMatcher("org"); assertTrue(ca.matches("org.foo.should.match")); assertFalse(ca.matches("bar.should.not.match")); } @Test public void starAndQuestionMark() { ClassNameMatcher ca = new WildcardClassNameMatcher("org?apache?something"); assertTrue(ca.matches("org.apache_something.more")); assertFalse(ca.matches("org..apache_something.more")); }
### Question: RegexpClassNameMatcher implements ClassNameMatcher { @Override public boolean matches(String className) { return pattern.matcher(className).matches(); } RegexpClassNameMatcher(String regex); RegexpClassNameMatcher(Pattern pattern); @Override boolean matches(String className); }### Answer: @Test public void testSimplePatternFromString() { ClassNameMatcher ca = new RegexpClassNameMatcher("foo."); assertTrue(ca.matches("foo.should.match")); assertFalse(ca.matches("bar.should.not.match")); } @Test public void testSimplePatternFromPattern() { ClassNameMatcher ca = new RegexpClassNameMatcher(Pattern.compile("foo.")); assertTrue(ca.matches("foo.should.match")); assertFalse(ca.matches("bar.should.not.match")); } @Test public void testOrPattern() { ClassNameMatcher ca = new RegexpClassNameMatcher("foo.\|bar."); assertTrue(ca.matches("foo.should.match")); assertTrue(ca.matches("bar.should.match")); assertFalse(ca.matches("zoo.should.not.match")); }
### Question: Elements extends ArrayList<Element> { public Elements parents() { HashSet<Element> combo = new LinkedHashSet<>(); for (Element e: this) { combo.addAll(e.parents()); } return new Elements(combo); } 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 parents() { Document doc = Jsoup.parse("<div><p>Hello</p></div><p>There</p>"); Elements parents = doc.select("p").parents(); assertEquals(3, parents.size()); assertEquals("div", parents.get(0).tagName()); assertEquals("body", parents.get(1).tagName()); assertEquals("html", parents.get(2).tagName()); }
### Question: Elements extends ArrayList<Element> { public Elements not(String query) { Elements out = Selector.select(query, this); return Selector.filterOut(this, out); } 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 not() { Document doc = Jsoup.parse("<div id=1><p>One</p></div> <div id=2><p><span>Two</span></p></div>"); Elements div1 = doc.select("div").not(":has(p > span)"); assertEquals(1, div1.size()); assertEquals("1", div1.first().id()); Elements div2 = doc.select("div").not("#1"); assertEquals(1, div2.size()); assertEquals("2", div2.first().id()); }
### Question: ValidatingObjectInputStream extends ObjectInputStream { public ValidatingObjectInputStream reject(Class<?>... classes) { for (Class<?> c : classes) { rejectMatchers.add(new FullClassNameMatcher(c.getName())); } return this; } ValidatingObjectInputStream(InputStream input); ValidatingObjectInputStream accept(Class<?>... classes); ValidatingObjectInputStream reject(Class<?>... classes); ValidatingObjectInputStream accept(String... patterns); ValidatingObjectInputStream reject(String... patterns); ValidatingObjectInputStream accept(Pattern pattern); ValidatingObjectInputStream reject(Pattern pattern); ValidatingObjectInputStream accept(ClassNameMatcher m); ValidatingObjectInputStream reject(ClassNameMatcher m); }### Answer: @Test(expected = InvalidClassException.class) public void reject() throws Exception { assertSerialization( willClose(new ValidatingObjectInputStream(testStream)) .accept(Long.class) .reject(MockSerializedClass.class, Integer.class) ); } @Test(expected = InvalidClassException.class) public void rejectOnly() throws Exception { assertSerialization( willClose(new ValidatingObjectInputStream(testStream)) .reject(Integer.class) ); } @Test(expected = RuntimeException.class) public void customInvalidMethod() throws Exception { class CustomVOIS extends ValidatingObjectInputStream { CustomVOIS(InputStream is) throws IOException { super(is); } @Override protected void invalidClassNameFound(String className) throws InvalidClassException { throw new RuntimeException("Custom exception"); } }; assertSerialization( willClose(new CustomVOIS(testStream)) .reject(Integer.class) ); }
### Question: PathFileComparator extends AbstractFileComparator implements Serializable { public int compare(final File file1, final File file2) { return caseSensitivity.checkCompareTo(file1.getPath(), file2.getPath()); } PathFileComparator(); PathFileComparator(final IOCase caseSensitivity); int compare(final File file1, final File file2); @Override String toString(); static final Comparator<File> PATH_COMPARATOR; static final Comparator<File> PATH_REVERSE; static final Comparator<File> PATH_INSENSITIVE_COMPARATOR; static final Comparator<File> PATH_INSENSITIVE_REVERSE; static final Comparator<File> PATH_SYSTEM_COMPARATOR; static final Comparator<File> PATH_SYSTEM_REVERSE; }### Answer: @Test public void testCaseSensitivity() { final File file3 = new File("FOO/file.txt"); final Comparator<File> sensitive = new PathFileComparator(null); assertTrue("sensitive file1 & file2 = 0", sensitive.compare(equalFile1, equalFile2) == 0); assertTrue("sensitive file1 & file3 > 0", sensitive.compare(equalFile1, file3) > 0); assertTrue("sensitive file1 & less > 0", sensitive.compare(equalFile1, lessFile) > 0); final Comparator<File> insensitive = PathFileComparator.PATH_INSENSITIVE_COMPARATOR; assertTrue("insensitive file1 & file2 = 0", insensitive.compare(equalFile1, equalFile2) == 0); assertTrue("insensitive file1 & file3 = 0", insensitive.compare(equalFile1, file3) == 0); assertTrue("insensitive file1 & file4 > 0", insensitive.compare(equalFile1, lessFile) > 0); assertTrue("insensitive file3 & less > 0", insensitive.compare(file3, lessFile) > 0); }
### Question: NameFileComparator extends AbstractFileComparator implements Serializable { public int compare(final File file1, final File file2) { return caseSensitivity.checkCompareTo(file1.getName(), file2.getName()); } NameFileComparator(); NameFileComparator(final IOCase caseSensitivity); int compare(final File file1, final File file2); @Override String toString(); static final Comparator<File> NAME_COMPARATOR; static final Comparator<File> NAME_REVERSE; static final Comparator<File> NAME_INSENSITIVE_COMPARATOR; static final Comparator<File> NAME_INSENSITIVE_REVERSE; static final Comparator<File> NAME_SYSTEM_COMPARATOR; static final Comparator<File> NAME_SYSTEM_REVERSE; }### Answer: @Test public void testCaseSensitivity() { final File file3 = new File("a/FOO.txt"); final Comparator<File> sensitive = new NameFileComparator(null); assertTrue("sensitive file1 & file2 = 0", sensitive.compare(equalFile1, equalFile2) == 0); assertTrue("sensitive file1 & file3 > 0", sensitive.compare(equalFile1, file3) > 0); assertTrue("sensitive file1 & less > 0", sensitive.compare(equalFile1, lessFile) > 0); final Comparator<File> insensitive = NameFileComparator.NAME_INSENSITIVE_COMPARATOR; assertTrue("insensitive file1 & file2 = 0", insensitive.compare(equalFile1, equalFile2) == 0); assertTrue("insensitive file1 & file3 = 0", insensitive.compare(equalFile1, file3) == 0); assertTrue("insensitive file1 & file4 > 0", insensitive.compare(equalFile1, lessFile) > 0); assertTrue("insensitive file3 & less > 0", insensitive.compare(file3, lessFile) > 0); }
### Question: SizeFileComparator extends AbstractFileComparator implements Serializable { public int compare(final File file1, final File file2) { long size1 = 0; if (file1.isDirectory()) { size1 = sumDirectoryContents && file1.exists() ? FileUtils.sizeOfDirectory(file1) : 0; } else { size1 = file1.length(); } long size2 = 0; if (file2.isDirectory()) { size2 = sumDirectoryContents && file2.exists() ? FileUtils.sizeOfDirectory(file2) : 0; } else { size2 = file2.length(); } final long result = size1 - size2; if (result < 0) { return -1; } else if (result > 0) { return 1; } else { return 0; } } SizeFileComparator(); SizeFileComparator(final boolean sumDirectoryContents); int compare(final File file1, final File file2); @Override String toString(); static final Comparator<File> SIZE_COMPARATOR; static final Comparator<File> SIZE_REVERSE; static final Comparator<File> SIZE_SUMDIR_COMPARATOR; static final Comparator<File> SIZE_SUMDIR_REVERSE; }### Answer: @Test public void testNonexistantFile() { final File nonexistantFile = new File(new File("."), "nonexistant.txt"); assertFalse(nonexistantFile.exists()); assertTrue("less", comparator.compare(nonexistantFile, moreFile) < 0); } @Test public void testCompareDirectorySizes() { assertEquals("sumDirectoryContents=false", 0, comparator.compare(smallerDir, largerDir)); assertEquals("less", -1, SizeFileComparator.SIZE_SUMDIR_COMPARATOR.compare(smallerDir, largerDir)); assertEquals("less", 1, SizeFileComparator.SIZE_SUMDIR_REVERSE.compare(smallerDir, largerDir)); }
### Question: ExtensionFileComparator extends AbstractFileComparator implements Serializable { public int compare(final File file1, final File file2) { final String suffix1 = FilenameUtils.getExtension(file1.getName()); final String suffix2 = FilenameUtils.getExtension(file2.getName()); return caseSensitivity.checkCompareTo(suffix1, suffix2); } ExtensionFileComparator(); ExtensionFileComparator(final IOCase caseSensitivity); int compare(final File file1, final File file2); @Override String toString(); static final Comparator<File> EXTENSION_COMPARATOR; static final Comparator<File> EXTENSION_REVERSE; static final Comparator<File> EXTENSION_INSENSITIVE_COMPARATOR; static final Comparator<File> EXTENSION_INSENSITIVE_REVERSE; static final Comparator<File> EXTENSION_SYSTEM_COMPARATOR; static final Comparator<File> EXTENSION_SYSTEM_REVERSE; }### Answer: @Test public void testCaseSensitivity() { final File file3 = new File("abc.FOO"); final Comparator<File> sensitive = new ExtensionFileComparator(null); assertTrue("sensitive file1 & file2 = 0", sensitive.compare(equalFile1, equalFile2) == 0); assertTrue("sensitive file1 & file3 > 0", sensitive.compare(equalFile1, file3) > 0); assertTrue("sensitive file1 & less > 0", sensitive.compare(equalFile1, lessFile) > 0); final Comparator<File> insensitive = ExtensionFileComparator.EXTENSION_INSENSITIVE_COMPARATOR; assertTrue("insensitive file1 & file2 = 0", insensitive.compare(equalFile1, equalFile2) == 0); assertTrue("insensitive file1 & file3 = 0", insensitive.compare(equalFile1, file3) == 0); assertTrue("insensitive file1 & file4 > 0", insensitive.compare(equalFile1, lessFile) > 0); assertTrue("insensitive file3 & less > 0", insensitive.compare(file3, lessFile) > 0); }
### Question: CompositeFileComparator extends AbstractFileComparator implements Serializable { public int compare(final File file1, final File file2) { int result = 0; for (final Comparator<File> delegate : delegates) { result = delegate.compare(file1, file2); if (result != 0) { break; } } return result; } @SuppressWarnings("unchecked") // casts 1 & 2 must be OK because types are already correct CompositeFileComparator(final Comparator<File>... delegates); @SuppressWarnings("unchecked") // casts 1 & 2 must be OK because types are already correct CompositeFileComparator(final Iterable<Comparator<File>> delegates); int compare(final File file1, final File file2); @Override String toString(); }### Answer: @Test public void constructorIterable_order() { final List<Comparator<File>> list = new ArrayList<Comparator<File>>(); list.add(SizeFileComparator.SIZE_COMPARATOR); list.add(ExtensionFileComparator.EXTENSION_COMPARATOR); final Comparator<File> c = new CompositeFileComparator(list); assertEquals("equal", 0, c.compare(equalFile1, equalFile2)); assertTrue("less", c.compare(lessFile, moreFile) < 0); assertTrue("more", c.compare(moreFile, lessFile) > 0); }
### Question: ClosedInputStream extends InputStream { @Override public int read() { return EOF; } @Override int read(); static final ClosedInputStream CLOSED_INPUT_STREAM; }### Answer: @Test public void testRead() throws Exception { final ClosedInputStream cis = new ClosedInputStream(); assertEquals("read()", -1, cis.read()); cis.close(); }
### Question: NullReader extends Reader { @Override public int read() throws IOException { if (eof) { throw new IOException("Read after end of file"); } if (position == size) { return doEndOfFile(); } position++; return processChar(); } NullReader(final long size); NullReader(final long size, final boolean markSupported, final boolean throwEofException); long getPosition(); long getSize(); @Override void close(); @Override synchronized void mark(final int readlimit); @Override boolean markSupported(); @Override int read(); @Override int read(final char[] chars); @Override int read(final char[] chars, final int offset, final int length); @Override synchronized void reset(); @Override long skip(final long numberOfChars); }### Answer: @Test public void testRead() throws Exception { final int size = 5; final TestNullReader reader = new TestNullReader(size); for (int i = 0; i < size; i++) { assertEquals("Check Value [" + i + "]", i, reader.read()); } assertEquals("End of File", -1, reader.read()); try { final int result = reader.read(); fail("Should have thrown an IOException, value=[" + result + "]"); } catch (final IOException e) { assertEquals("Read after end of file", e.getMessage()); } reader.close(); assertEquals("Available after close", 0, reader.getPosition()); }
### Question: NullReader extends Reader { @Override public long skip(final long numberOfChars) throws IOException { if (eof) { throw new IOException("Skip after end of file"); } if (position == size) { return doEndOfFile(); } position += numberOfChars; long returnLength = numberOfChars; if (position > size) { returnLength = numberOfChars - (position - size); position = size; } return returnLength; } NullReader(final long size); NullReader(final long size, final boolean markSupported, final boolean throwEofException); long getPosition(); long getSize(); @Override void close(); @Override synchronized void mark(final int readlimit); @Override boolean markSupported(); @Override int read(); @Override int read(final char[] chars); @Override int read(final char[] chars, final int offset, final int length); @Override synchronized void reset(); @Override long skip(final long numberOfChars); }### Answer: @Test public void testSkip() throws Exception { final Reader reader = new TestNullReader(10, true, false); assertEquals("Read 1", 0, reader.read()); assertEquals("Read 2", 1, reader.read()); assertEquals("Skip 1", 5, reader.skip(5)); assertEquals("Read 3", 7, reader.read()); assertEquals("Skip 2", 2, reader.skip(5)); assertEquals("Skip 3 (EOF)", -1, reader.skip(5)); try { reader.skip(5); fail("Expected IOException for skipping after end of file"); } catch (final IOException e) { assertEquals("Skip after EOF IOException message", "Skip after end of file", e.getMessage()); } reader.close(); }
### Question: CloseShieldInputStream extends ProxyInputStream { @Override public void close() { in = new ClosedInputStream(); } CloseShieldInputStream(final InputStream in); @Override void close(); }### Answer: @Test public void testClose() throws IOException { shielded.close(); assertFalse("closed", closed); assertEquals("read()", -1, shielded.read()); assertEquals("read()", data[0], original.read()); }
### Question: CharSequenceInputStream extends InputStream { @Override public boolean markSupported() { return true; } CharSequenceInputStream(final CharSequence cs, final Charset charset, final int bufferSize); CharSequenceInputStream(final CharSequence cs, final String charset, final int bufferSize); CharSequenceInputStream(final CharSequence cs, final Charset charset); CharSequenceInputStream(final CharSequence cs, final String charset); @Override int read(final byte[] b, int off, int len); @Override int read(); @Override int read(final byte[] b); @Override long skip(long n); @Override int available(); @Override void close(); @Override synchronized void mark(final int readlimit); @Override synchronized void reset(); @Override boolean markSupported(); }### Answer: @Test public void testMarkSupported() throws Exception { final InputStream r = new CharSequenceInputStream("test", "UTF-8"); try { assertTrue(r.markSupported()); } finally { r.close(); } }
### Question: CharSequenceInputStream extends InputStream { @Override public int available() throws IOException { return this.bbuf.remaining() + this.cbuf.remaining(); } CharSequenceInputStream(final CharSequence cs, final Charset charset, final int bufferSize); CharSequenceInputStream(final CharSequence cs, final String charset, final int bufferSize); CharSequenceInputStream(final CharSequence cs, final Charset charset); CharSequenceInputStream(final CharSequence cs, final String charset); @Override int read(final byte[] b, int off, int len); @Override int read(); @Override int read(final byte[] b); @Override long skip(long n); @Override int available(); @Override void close(); @Override synchronized void mark(final int readlimit); @Override synchronized void reset(); @Override boolean markSupported(); }### Answer: @Test public void testAvailable() throws Exception { for (final String csName : Charset.availableCharsets().keySet()) { try { if (isAvailabilityTestableForCharset(csName)) { testAvailableSkip(csName); testAvailableRead(csName); } } catch (UnsupportedOperationException e){ fail("Operation not supported for " + csName); } } }
### Question: NullInputStream extends InputStream { @Override public int read() throws IOException { if (eof) { throw new IOException("Read after end of file"); } if (position == size) { return doEndOfFile(); } position++; return processByte(); } NullInputStream(final long size); NullInputStream(final long size, final boolean markSupported, final boolean throwEofException); long getPosition(); long getSize(); @Override int available(); @Override void close(); @Override synchronized void mark(final int readlimit); @Override boolean markSupported(); @Override int read(); @Override int read(final byte[] bytes); @Override int read(final byte[] bytes, final int offset, final int length); @Override synchronized void reset(); @Override long skip(final long numberOfBytes); }### Answer: @Test public void testRead() throws Exception { final int size = 5; final InputStream input = new TestNullInputStream(size); for (int i = 0; i < size; i++) { assertEquals("Check Size [" + i + "]", size - i, input.available()); assertEquals("Check Value [" + i + "]", i, input.read()); } assertEquals("Available after contents all read", 0, input.available()); assertEquals("End of File", -1, input.read()); assertEquals("Available after End of File", 0, input.available()); try { final int result = input.read(); fail("Should have thrown an IOException, byte=[" + result + "]"); } catch (final IOException e) { assertEquals("Read after end of file", e.getMessage()); } input.close(); assertEquals("Available after close", size, input.available()); }
### Question: NullInputStream extends InputStream { @Override public long skip(final long numberOfBytes) throws IOException { if (eof) { throw new IOException("Skip after end of file"); } if (position == size) { return doEndOfFile(); } position += numberOfBytes; long returnLength = numberOfBytes; if (position > size) { returnLength = numberOfBytes - (position - size); position = size; } return returnLength; } NullInputStream(final long size); NullInputStream(final long size, final boolean markSupported, final boolean throwEofException); long getPosition(); long getSize(); @Override int available(); @Override void close(); @Override synchronized void mark(final int readlimit); @Override boolean markSupported(); @Override int read(); @Override int read(final byte[] bytes); @Override int read(final byte[] bytes, final int offset, final int length); @Override synchronized void reset(); @Override long skip(final long numberOfBytes); }### Answer: @Test public void testSkip() throws Exception { final InputStream input = new TestNullInputStream(10, true, false); assertEquals("Read 1", 0, input.read()); assertEquals("Read 2", 1, input.read()); assertEquals("Skip 1", 5, input.skip(5)); assertEquals("Read 3", 7, input.read()); assertEquals("Skip 2", 2, input.skip(5)); assertEquals("Skip 3 (EOF)", -1, input.skip(5)); try { input.skip(5); fail("Expected IOException for skipping after end of file"); } catch (final IOException e) { assertEquals("Skip after EOF IOException message", "Skip after end of file", e.getMessage()); } input.close(); }
### Question: CharSequenceReader extends Reader implements Serializable { @Override public void close() { idx = 0; mark = 0; } CharSequenceReader(final CharSequence charSequence); @Override void close(); @Override void mark(final int readAheadLimit); @Override boolean markSupported(); @Override int read(); @Override int read(final char[] array, final int offset, final int length); @Override void reset(); @Override long skip(final long n); @Override String toString(); }### Answer: @Test public void testClose() throws IOException { final Reader reader = new CharSequenceReader("FooBar"); checkRead(reader, "Foo"); reader.close(); checkRead(reader, "Foo"); }
### Question: CharSequenceReader extends Reader implements Serializable { @Override public boolean markSupported() { return true; } CharSequenceReader(final CharSequence charSequence); @Override void close(); @Override void mark(final int readAheadLimit); @Override boolean markSupported(); @Override int read(); @Override int read(final char[] array, final int offset, final int length); @Override void reset(); @Override long skip(final long n); @Override String toString(); }### Answer: @Test public void testMarkSupported() throws Exception { final Reader reader = new CharSequenceReader("FooBar"); assertTrue(reader.markSupported()); reader.close(); }
### Question: CharSequenceReader extends Reader implements Serializable { @Override public void mark(final int readAheadLimit) { mark = idx; } CharSequenceReader(final CharSequence charSequence); @Override void close(); @Override void mark(final int readAheadLimit); @Override boolean markSupported(); @Override int read(); @Override int read(final char[] array, final int offset, final int length); @Override void reset(); @Override long skip(final long n); @Override String toString(); }### Answer: @Test public void testMark() throws IOException { final Reader reader = new CharSequenceReader("FooBar"); checkRead(reader, "Foo"); reader.mark(0); checkRead(reader, "Bar"); reader.reset(); checkRead(reader, "Bar"); reader.close(); checkRead(reader, "Foo"); reader.reset(); checkRead(reader, "Foo"); }
### Question: CharSequenceReader extends Reader implements Serializable { @Override public long skip(final long n) { if (n < 0) { throw new IllegalArgumentException( "Number of characters to skip is less than zero: " + n); } if (idx >= charSequence.length()) { return EOF; } final int dest = (int)Math.min(charSequence.length(), idx + n); final int count = dest - idx; idx = dest; return count; } CharSequenceReader(final CharSequence charSequence); @Override void close(); @Override void mark(final int readAheadLimit); @Override boolean markSupported(); @Override int read(); @Override int read(final char[] array, final int offset, final int length); @Override void reset(); @Override long skip(final long n); @Override String toString(); }### Answer: @Test public void testSkip() throws IOException { final Reader reader = new CharSequenceReader("FooBar"); assertEquals(3, reader.skip(3)); checkRead(reader, "Bar"); assertEquals(-1, reader.skip(3)); reader.reset(); assertEquals(2, reader.skip(2)); assertEquals(4, reader.skip(10)); assertEquals(-1, reader.skip(1)); reader.close(); assertEquals(6, reader.skip(20)); assertEquals(-1, reader.read()); }
### Question: CharSequenceReader extends Reader implements Serializable { @Override public int read() { if (idx >= charSequence.length()) { return EOF; } else { return charSequence.charAt(idx++); } } CharSequenceReader(final CharSequence charSequence); @Override void close(); @Override void mark(final int readAheadLimit); @Override boolean markSupported(); @Override int read(); @Override int read(final char[] array, final int offset, final int length); @Override void reset(); @Override long skip(final long n); @Override String toString(); }### Answer: @Test public void testRead() throws IOException { final Reader reader = new CharSequenceReader("Foo"); assertEquals('F', reader.read()); assertEquals('o', reader.read()); assertEquals('o', reader.read()); assertEquals(-1, reader.read()); assertEquals(-1, reader.read()); reader.close(); }
### Question: SwappedDataInputStream extends ProxyInputStream implements DataInput { public boolean readBoolean() throws IOException, EOFException { return 0 != readByte(); } SwappedDataInputStream( final InputStream input ); boolean readBoolean(); byte readByte(); char readChar(); double readDouble(); float readFloat(); void readFully( final byte[] data ); void readFully( final byte[] data, final int offset, final int length ); int readInt(); String readLine(); long readLong(); short readShort(); int readUnsignedByte(); int readUnsignedShort(); String readUTF(); int skipBytes( final int count ); }### Answer: @Test public void testReadBoolean() throws IOException { bytes = new byte[] { 0x00, 0x01, 0x02, }; final ByteArrayInputStream bais = new ByteArrayInputStream( bytes ); final SwappedDataInputStream sdis = new SwappedDataInputStream( bais ); assertEquals( false, sdis.readBoolean() ); assertEquals( true, sdis.readBoolean() ); assertEquals( true, sdis.readBoolean() ); sdis.close(); }
### Question: SwappedDataInputStream extends ProxyInputStream implements DataInput { public byte readByte() throws IOException, EOFException { return (byte)in.read(); } SwappedDataInputStream( final InputStream input ); boolean readBoolean(); byte readByte(); char readChar(); double readDouble(); float readFloat(); void readFully( final byte[] data ); void readFully( final byte[] data, final int offset, final int length ); int readInt(); String readLine(); long readLong(); short readShort(); int readUnsignedByte(); int readUnsignedShort(); String readUTF(); int skipBytes( final int count ); }### Answer: @Test public void testReadByte() throws IOException { assertEquals( 0x01, this.sdis.readByte() ); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.