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: RandomSeedUtils { public static byte[] getLastDigestEightBytes(byte[] bytes) { byte[] hash = Sha256Hash.hashTwice(bytes); byte[] result = new byte[8]; System.arraycopy(hash, bytes.length - 8, result, 0, 8); return result; } static byte[] createRandomSeed(); static byte[] getLastDigestEightBytes(byte[] bytes); static RandomSeedStatusPo CACHE_SEED; }### Answer: @Test public void getLastDigestEightBytes() { byte[] seed = RandomSeedUtils.createRandomSeed(); byte[] hash = RandomSeedUtils.getLastDigestEightBytes(seed); byte[] hash2 = RandomSeedUtils.getLastDigestEightBytes(seed); assertTrue(ArraysTool.arrayEquals(hash, hash2)); assertEquals(hash.length, 8); }
### Question: BlockQueueProvider { public boolean put(BlockContainer blockContainer) { boolean receive = (blockContainer.getStatus() == BlockContainerStatus.RECEIVED); if (receive) { int status = BlockContainerStatus.RECEIVED; checkDownloadService(); if (!downloadService.isDownloadSuccess().isSuccess()) { status = BlockContainerStatus.DOWNLOADING; } blockContainer.setStatus(status); blockQueue.offer(blockContainer); } else { if (downloadBlockQueueHasDestory) { initDownloadQueue(); } downloadBlockQueue.offer(blockContainer); } return true; } private BlockQueueProvider(); static BlockQueueProvider getInstance(); boolean put(BlockContainer blockContainer); BlockContainer get(); long size(); void clear(); }### Answer: @Test public void testPut() { assertNotNull(blockQueueProvider); assertEquals(0, blockQueueProvider.size()); Block block = new Block(); boolean result = blockQueueProvider.put(new BlockContainer(block, BlockContainerStatus.RECEIVED)); assertTrue(result); assertEquals(1, blockQueueProvider.size()); }
### Question: BlockQueueProvider { public BlockContainer get() { BlockContainer blockContainer = null; if (!downloadBlockQueueHasDestory) { blockContainer = downloadBlockQueue.poll(); } checkDownloadService(); boolean hasDownloadSuccess = downloadService.isDownloadSuccess().isSuccess(); if (blockContainer == null && hasDownloadSuccess && !downloadBlockQueueHasDestory) { downloadBlockQueueHasDestory = true; if (blockContainer == null) { blockContainer = blockQueue.poll(); } } else if (hasDownloadSuccess && blockContainer == null) { blockContainer = blockQueue.poll(); } return blockContainer; } private BlockQueueProvider(); static BlockQueueProvider getInstance(); boolean put(BlockContainer blockContainer); BlockContainer get(); long size(); void clear(); }### Answer: @Test public void testGet() { assertNotNull(blockQueueProvider); assertEquals(0, blockQueueProvider.size()); if(downloadService.isDownloadSuccess().isSuccess()) { downloadService.setDownloadSuccess(false); } Block block = new Block(); boolean result = blockQueueProvider.put(new BlockContainer(block, BlockContainerStatus.RECEIVED)); assertTrue(result); assertEquals(1, blockQueueProvider.size()); BlockContainer blockContainer = blockQueueProvider.get(); assertNull(blockContainer); downloadService.setDownloadSuccess(true); blockContainer = blockQueueProvider.get(); assertNotNull(blockContainer); assertEquals(blockContainer.getBlock(), block); assertEquals(blockContainer.getStatus(), BlockContainerStatus.DOWNLOADING); assertEquals(0, blockQueueProvider.size()); block = new Block(); result = blockQueueProvider.put(new BlockContainer(block, BlockContainerStatus.RECEIVED)); assertTrue(result); blockContainer = blockQueueProvider.get(); assertNotNull(blockContainer); assertEquals(blockContainer.getBlock(), block); assertEquals(blockContainer.getStatus(), BlockContainerStatus.RECEIVED); }
### Question: BlockProcessTask implements Runnable { @Override public void run() { Lockers.CHAIN_LOCK.lock(); try { doTask(); } catch (Exception e) { Log.error(e); } catch (Error e) { Log.error(e); } catch (Throwable e) { Log.error(e); } finally { Lockers.CHAIN_LOCK.unlock(); } } BlockProcessTask(BlockProcess blockProcess); @Override void run(); }### Answer: @Test public void testRun() { assertNotNull(blockProcessTask); if(downloadService.isDownloadSuccess().isSuccess()) { downloadService.setDownloadSuccess(false); } ConsensusStatusContext.setConsensusStatus(ConsensusStatus.WAIT_RUNNING); blockProcessTask.run(); assert(!ConsensusStatusContext.isRunning()); downloadService.setDownloadSuccess(true); blockProcessTask.run(); assert(ConsensusStatusContext.isRunning()); }
### Question: ChainContainer implements Cloneable { public MeetingRound getCurrentRound() { return roundManager.getCurrentRound(); } ChainContainer(Chain chain); boolean addBlock(Block block); Result verifyBlock(Block block); Result verifyBlock(Block block, boolean isDownload, boolean isNeedCheckCoinBaseTx); boolean verifyCoinBaseTx(Block block, MeetingRound currentRound, MeetingMember member); boolean verifyPunishTx(Block block, MeetingRound currentRound, MeetingMember member); Result verifyAndAddBlock(Block block, boolean isDownload, boolean isNeedCheckCoinBaseTx); boolean rollback(Block block); ChainContainer getBeforeTheForkChain(ChainContainer chainContainer); ChainContainer getAfterTheForkChain(ChainContainer chainContainer); MeetingRound getCurrentRound(); MeetingRound getOrResetCurrentRound(); MeetingRound getOrResetCurrentRound(boolean isRealTime); MeetingRound initRound(); void clearRound(int count); Block getBestBlock(); Chain getChain(); void setChain(Chain chain); @Override boolean equals(Object obj); RoundManager getRoundManager(); }### Answer: @Test public void testInit() { assertNotNull(chain); assertNotNull(chainContainer); assertNotNull(chainContainer.getCurrentRound()); assertEquals(chainContainer.getCurrentRound().getMemberCount(), 1); }
### Question: TemporaryCacheManager { public boolean cacheTx(Transaction tx) { return txCacheMap.put(tx.getHash(), tx); } private TemporaryCacheManager(); static TemporaryCacheManager getInstance(); void cacheSmallBlock(SmallBlock smallBlock); void cacheSmallBlockWithRequest(NulsDigestData requestHash, SmallBlock smallBlock); SmallBlock getSmallBlockByRequest(NulsDigestData requestHash); SmallBlock getSmallBlockByHash(NulsDigestData blockHash); boolean cacheTx(Transaction tx); Transaction getTx(NulsDigestData hash); void removeSmallBlock(NulsDigestData hash); void clear(); void destroy(); boolean containsTx(NulsDigestData txHash); int getSmallBlockCount(); int getTxCount(); }### Answer: @Test public void cacheTx() { Transaction tx = new CacheTestTx(); tx.setTime(1234567654L); try { tx.setHash(NulsDigestData.calcDigestData(tx.serializeForHash())); } catch (IOException e) { Log.error(e); } manager.cacheTx(tx); assertTrue(true); getTx(tx.getHash(), tx); }
### Question: NulsDigestData extends BaseNulsData { public static NulsDigestData calcDigestData(BaseNulsData data) { return calcDigestData(data, (byte) 0); } NulsDigestData(); NulsDigestData(byte algType, byte[] bytes); @Override int size(); @Override void parse(NulsByteBuffer byteBuffer); byte getDigestAlgType(); void setDigestAlgType(byte digestAlgType); String getDigestHex(); static NulsDigestData fromDigestHex(String hex); static boolean validHash(String hex); static NulsDigestData calcDigestData(BaseNulsData data); static NulsDigestData calcDigestData(BaseNulsData data, byte digestAlgType); byte[] getDigestBytes(); static NulsDigestData calcDigestData(byte[] data); static NulsDigestData calcDigestData(byte[] data, byte digestAlgType); static NulsDigestData calcMerkleDigestData(List<NulsDigestData> ddList); @Override boolean equals(Object obj); @Override String toString(); @Override int hashCode(); static final int HASH_LENGTH; static byte DIGEST_ALG_SHA256; static byte DIGEST_ALG_SHA160; }### Answer: @Test public void test() { NulsDigestData hash = NulsDigestData.calcDigestData(new byte[32]); System.out.println(hash); assertTrue(true); }
### Question: MessageBusServiceImpl implements MessageBusService { @Override public String subscribeMessage(Class<? extends BaseMessage> messageClass, NulsMessageHandler<? extends BaseMessage> messageHandler) { MessageManager.putMessage(messageClass); return handlerManager.registerMessageHandler(null, messageClass, messageHandler); } @Override String subscribeMessage(Class<? extends BaseMessage> messageClass, NulsMessageHandler<? extends BaseMessage> messageHandler); @Override void unsubscribeMessage(String subscribeId); @Override void receiveMessage(BaseMessage message, Node node); void shutdown(); @Override Result<List<String>> broadcast(BaseMessage message, Node excludeNode, boolean aysn, int percent); @Override Result sendToNode(BaseMessage message, Node node, boolean aysn); @Override Result<? extends BaseMessage> getMessageInstance(short moduleId, int type); }### Answer: @Test public void subscribeMessage() throws Exception { subscribe(); assertNotNull(handlerId); Field field = messageBusService.getClass().getDeclaredField("processorManager"); field.setAccessible(true); DispatchManager processorManager = (DispatchManager) field.get(messageBusService); Class processorManagerClass = processorManager.getClass(); Field handlerMapField = processorManagerClass.getDeclaredField("handlerMap"); handlerMapField.setAccessible(true); Map<String, NulsMessageHandler> handlerMap = (Map<String, NulsMessageHandler>) handlerMapField.get(processorManager); assertNotNull(handlerMap.get(handlerId)); assertEquals(handlerMap.get(handlerId), messageHandler); Field messageHandlerMappingField = processorManagerClass.getDeclaredField("messageHandlerMapping"); messageHandlerMappingField.setAccessible(true); Map<Class, Set<String>> messageHandlerMapping = (Map<Class, Set<String>>) messageHandlerMappingField.get(processorManager); assertNotNull(messageHandlerMapping.get(block)); assertTrue(messageHandlerMapping.get(block).contains(handlerId)); }
### Question: MessageBusServiceImpl implements MessageBusService { @Override public void unsubscribeMessage(String subscribeId) { this.handlerManager.removeMessageHandler(subscribeId); } @Override String subscribeMessage(Class<? extends BaseMessage> messageClass, NulsMessageHandler<? extends BaseMessage> messageHandler); @Override void unsubscribeMessage(String subscribeId); @Override void receiveMessage(BaseMessage message, Node node); void shutdown(); @Override Result<List<String>> broadcast(BaseMessage message, Node excludeNode, boolean aysn, int percent); @Override Result sendToNode(BaseMessage message, Node node, boolean aysn); @Override Result<? extends BaseMessage> getMessageInstance(short moduleId, int type); }### Answer: @Test public void unsubscribeMessage() throws Exception { messageBusService.unsubscribeMessage(handlerId); Field field = messageBusService.getClass().getDeclaredField("processorManager"); field.setAccessible(true); DispatchManager processorManager = (DispatchManager) field.get(messageBusService); Class processorManagerClass = processorManager.getClass(); Field handlerMapField = processorManagerClass.getDeclaredField("handlerMap"); handlerMapField.setAccessible(true); Map<String, NulsMessageHandler> handlerMap = (Map<String, NulsMessageHandler>) handlerMapField.get(processorManager); assertNull(handlerMap.get(handlerId)); }
### Question: MessageBusServiceImpl implements MessageBusService { @Override public void receiveMessage(BaseMessage message, Node node) { try { this.processorManager.offer(new ProcessData(message, node)); } catch (Exception e) { Log.error(e); } } @Override String subscribeMessage(Class<? extends BaseMessage> messageClass, NulsMessageHandler<? extends BaseMessage> messageHandler); @Override void unsubscribeMessage(String subscribeId); @Override void receiveMessage(BaseMessage message, Node node); void shutdown(); @Override Result<List<String>> broadcast(BaseMessage message, Node excludeNode, boolean aysn, int percent); @Override Result sendToNode(BaseMessage message, Node node, boolean aysn); @Override Result<? extends BaseMessage> getMessageInstance(short moduleId, int type); }### Answer: @Test public void receiveMessage() { BlockMessage blockMessage = new BlockMessage(); Node node = new Node("192.168.1.90",8003,1); messageBusService.receiveMessage(blockMessage, node); }
### Question: MessageBusServiceImpl implements MessageBusService { @Override public Result<List<String>> broadcast(BaseMessage message, Node excludeNode, boolean aysn, int percent) { BroadcastResult result = networkService.sendToAllNode(message, excludeNode, aysn, percent); return getNodeIdListResult(result); } @Override String subscribeMessage(Class<? extends BaseMessage> messageClass, NulsMessageHandler<? extends BaseMessage> messageHandler); @Override void unsubscribeMessage(String subscribeId); @Override void receiveMessage(BaseMessage message, Node node); void shutdown(); @Override Result<List<String>> broadcast(BaseMessage message, Node excludeNode, boolean aysn, int percent); @Override Result sendToNode(BaseMessage message, Node node, boolean aysn); @Override Result<? extends BaseMessage> getMessageInstance(short moduleId, int type); }### Answer: @Test public void broadcastAndCache() { BlockMessage blockMessage = new BlockMessage(); Node node = new Node("192.168.1.90",8003,1); boolean aysn = true; Result<List<String>> result = messageBusService.broadcast(blockMessage, node, aysn,100); assertTrue(result.isSuccess()); assertTrue(result.getData().size()>0); }
### Question: TemporaryCacheManager { public void destroy() { this.smallBlockCacheMap.clear(); this.txCacheMap.clear(); } private TemporaryCacheManager(); static TemporaryCacheManager getInstance(); void cacheSmallBlock(SmallBlock smallBlock); void cacheSmallBlockWithRequest(NulsDigestData requestHash, SmallBlock smallBlock); SmallBlock getSmallBlockByRequest(NulsDigestData requestHash); SmallBlock getSmallBlockByHash(NulsDigestData blockHash); boolean cacheTx(Transaction tx); Transaction getTx(NulsDigestData hash); void removeSmallBlock(NulsDigestData hash); void clear(); void destroy(); boolean containsTx(NulsDigestData txHash); int getSmallBlockCount(); int getTxCount(); }### Answer: @Test public void destroy() { manager.destroy(); assertNull(EhCacheManager.getInstance().getCache("temp-small-block-cache")); assertNull(EhCacheManager.getInstance().getCache("temp-tx-cache")); }
### Question: MessageBusServiceImpl implements MessageBusService { @Override public Result sendToNode(BaseMessage message, Node node, boolean aysn) { BroadcastResult result = networkService.sendToNode(message, node, aysn); if (!result.isSuccess()) { Log.error("send to node fail reason: " + result.getErrorCode().getMsg() + "::::" + node.getId()); } return new Result(result.isSuccess(), result.getErrorCode(), null); } @Override String subscribeMessage(Class<? extends BaseMessage> messageClass, NulsMessageHandler<? extends BaseMessage> messageHandler); @Override void unsubscribeMessage(String subscribeId); @Override void receiveMessage(BaseMessage message, Node node); void shutdown(); @Override Result<List<String>> broadcast(BaseMessage message, Node excludeNode, boolean aysn, int percent); @Override Result sendToNode(BaseMessage message, Node node, boolean aysn); @Override Result<? extends BaseMessage> getMessageInstance(short moduleId, int type); }### Answer: @Test public void sendToNode() { BlockMessage blockMessage = new BlockMessage(); Node node = new Node("192.168.1.90",8003,1); boolean aysn = true; assertTrue(messageBusService.sendToNode(blockMessage, node, aysn).isSuccess()); }
### Question: MessageBusModuleBootstrap extends AbstractMessageBusModule { @Override public void start() { DispatchManager.getInstance().init(true); } @Override void init(); @Override void start(); @Override void shutdown(); @Override void destroy(); @Override String getInfo(); }### Answer: @Test public void start() { messageBusModuleBootstrap.start(); }
### Question: MessageBusModuleBootstrap extends AbstractMessageBusModule { @Override public void shutdown() { DispatchManager.getInstance().shutdown(); } @Override void init(); @Override void start(); @Override void shutdown(); @Override void destroy(); @Override String getInfo(); }### Answer: @Test public void shutdown() { messageBusModuleBootstrap.shutdown(); }
### Question: MessageBusModuleBootstrap extends AbstractMessageBusModule { @Override public void destroy() { } @Override void init(); @Override void start(); @Override void shutdown(); @Override void destroy(); @Override String getInfo(); }### Answer: @Test public void destroy() { messageBusModuleBootstrap.destroy(); }
### Question: AccountBaseService { public Result getPrivateKey(String address, String password) { if (!AddressTool.validAddress(address)) { return Result.getFailed(AccountErrorCode.ADDRESS_ERROR); } Account account = accountService.getAccount(address).getData(); if (null == account) { return Result.getFailed(AccountErrorCode.ACCOUNT_NOT_EXIST); } if (account.isEncrypted()) { try { byte[] priKeyBytes = priKeyBytes = account.getPriKey(password); return Result.getSuccess().setData(Hex.encode(priKeyBytes)); } catch (NulsException e) { return Result.getFailed(AccountErrorCode.PASSWORD_IS_WRONG); } } return Result.getFailed(AccountErrorCode.ACCOUNT_UNENCRYPTED); } Result setRemark(String address, String remark); Result getPrivateKey(String address, String password); Result getAllPrivateKey(String password); Result getAllPrivateKey(); Result setPassword(String address, String password); Result changePassword(String address, String oldPassword, String newPassword); }### Answer: @Test public void getPrivateKeyTest() { List<Account> accounts = this.accountService.createAccount(1, "nuls123456").getData(); Account account = accounts.get(0); Result result = accountBaseService.getPrivateKey(account.getAddress().toString(), "nuls123456"); assertTrue(result.isSuccess()); try { account.unlock("nuls123456"); } catch (NulsException e) { e.printStackTrace(); } assertArrayEquals(Hex.decode((String)result.getData()), account.getPriKey()); List<Account> accounts2 = this.accountService.createAccount(1, "").getData(); Account account2 = accounts2.get(0); Result result2 = accountBaseService.getPrivateKey(account2.getAddress().toString(), ""); assertTrue(result2.isSuccess()); assertArrayEquals(Hex.decode((String)result2.getData()), account2.getPriKey()); }
### Question: AccountBaseService { public Result setPassword(String address, String password) { if (!AddressTool.validAddress(address)) { return Result.getFailed(AccountErrorCode.ADDRESS_ERROR); } if (StringUtils.isBlank(password)) { return Result.getFailed(AccountErrorCode.NULL_PARAMETER); } if (!StringUtils.validPassword(password)) { return Result.getFailed(AccountErrorCode.PASSWORD_FORMAT_WRONG); } Account account = accountService.getAccount(address).getData(); if (null == account) { return Result.getFailed(AccountErrorCode.ACCOUNT_NOT_EXIST); } if (account.isEncrypted()) { return Result.getFailed(AccountErrorCode.ACCOUNT_IS_ALREADY_ENCRYPTED); } try { account.encrypt(password); Result result = accountStorageService.updateAccount(new AccountPo(account)); if (result.isFailed()) { return Result.getFailed(AccountErrorCode.FAILED); } accountCacheService.localAccountMaps.put(account.getAddress().getBase58(), account); } catch (NulsException e) { Log.error(e); return Result.getFailed(AccountErrorCode.FAILED); } return Result.getSuccess().setData(true); } Result setRemark(String address, String remark); Result getPrivateKey(String address, String password); Result getAllPrivateKey(String password); Result getAllPrivateKey(); Result setPassword(String address, String password); Result changePassword(String address, String oldPassword, String newPassword); }### Answer: @Test public void setPassword() { List<Account> accounts = this.accountService.createAccount(1, "").getData(); Account account = accounts.get(0); accountBaseService.setPassword(account.getAddress().toString(),"nuls123456"); Account acc = accountService.getAccount(account.getAddress()).getData(); try { assertTrue(acc.unlock("nuls123456")); assertArrayEquals(acc.getPriKey(), account.getPriKey()); } catch (NulsException e) { e.printStackTrace(); } }
### Question: CallContractData extends TransactionLogicData implements ContractData { public String[][] getArgs() { return args; } @Override int size(); @Override void parse(NulsByteBuffer byteBuffer); @Override byte[] getSender(); void setSender(byte[] sender); @Override byte[] getContractAddress(); void setContractAddress(byte[] contractAddress); @Override long getValue(); void setValue(long value); @Override long getGasLimit(); void setGasLimit(long gasLimit); @Override long getPrice(); void setPrice(long price); String getMethodName(); void setMethodName(String methodName); String getMethodDesc(); void setMethodDesc(String methodDesc); byte getArgsCount(); void setArgsCount(byte argsCount); String[][] getArgs(); void setArgs(String[][] args); @Override Set<byte[]> getAddresses(); }### Answer: @Test public void test1() { try { byte[] key = LedgerUtil.asBytes("aasdasdasdasda"); dbService.putModel(area, key, data); CallContractData dataConvert = dbService.getModel(area, key, CallContractData.class); System.out.println(dataConvert.toString()); String[][] strings = dataConvert.getArgs(); for(String[] bbb : strings) System.out.println(Arrays.toString(bbb)); } catch (Exception e) { e.printStackTrace(); Assert.fail(); } }
### Question: FileUtil { public static boolean deleteFolder(File folder) { if (!folder.exists()) { return true; } File[] files = folder.listFiles(); for (File file : files) { if (file.isFile()) { try { boolean b = file.delete(); if (!b) { Log.info("delete " + file.getName() + " result:" + b); mkNullToFile(file); } } catch (Exception e) { Log.error(e); } } else { deleteFolder(file); } } try { boolean b = folder.delete(); } catch (Exception e) { Log.error(e); } return true; } static File compress(File source, File target); static void decompress(String zipPath, String targetPath); static void copyFile(File source, File target); static void copyFolder(File source, File target); static void writeText(String text, String path); static boolean writeFile(byte[] bytes, String filePath); static boolean deleteFolder(File folder); static void deleteFolder(String path); }### Answer: @Test public void deleteFolder() { FileUtil.deleteFolder("C:\\Users\\Administrator\\Desktop\\release\\NULS-Wallet-0.9.10-windows-x64-for-test\\conf\\client-web"); }
### Question: UpgradeThread implements Runnable { private boolean download(String url, String filePath, String signature) throws IOException { if (!upgrading) { setFailedMessage("The upgrade has stopped"); return false; } byte[] bytes = HttpDownloadUtils.download(url); if (!verifySig(bytes, Hex.decode(signature))) { setFailedMessage("Signature verification is incorrect:" + url); return false; } boolean result = FileUtil.writeFile(bytes, filePath); if (!result) { setFailedMessage("Write file failed:" + filePath); } return result; } private UpgradeThread(); static UpgradeThread getInstance(); @Override void run(); boolean start(); boolean stop(); boolean isUpgrading(); UpgradeProcessDTO getProcess(); }### Answer: @Test public void download() { System.out.print("abcdefg"); System.out.print("\b"); System.out.print("\b"); System.out.print("\b"); }
### Question: PoConvertUtil { public static String getAgentId(NulsDigestData hash) { String hashHex = hash.getDigestHex(); return hashHex.substring(hashHex.length() - 8).toUpperCase(); } static Agent poToAgent(AgentPo agentPo); static AgentPo agentToPo(Agent agent); static Deposit poToDeposit(DepositPo po); static DepositPo depositToPo(Deposit deposit); static String getAgentId(NulsDigestData hash); }### Answer: @Test public void getAgentId() { NulsDigestData hash = NulsDigestData.calcDigestData("123123".getBytes()); System.out.println(PoConvertUtil.getAgentId(hash)); System.out.println(hash); assertTrue(true); }
### Question: ChainManager { public void newOrphanChain(Block block) { Chain orphanChain = new Chain(); orphanChain.initData(block); ChainContainer orphanChainContainer = new ChainContainer(orphanChain); orphanChains.add(orphanChainContainer); } ChainManager(); void newOrphanChain(Block block); boolean checkIsBeforeOrphanChainAndAdd(Block block); boolean checkIsAfterOrphanChainAndAdd(Block block); long getBestBlockHeight(); void clear(); ChainContainer getMasterChain(); void setMasterChain(ChainContainer masterChain); List<ChainContainer> getChains(); Block getBestBlock(); List<ChainContainer> getOrphanChains(); }### Answer: @Test public void testNewOrphanChain() { assertNotNull(chainManager); Block block = createBlock(); chainManager.newOrphanChain(block); assertEquals(1, chainManager.getOrphanChains().size()); }
### Question: ChainManager { public long getBestBlockHeight() { if(masterChain == null \|\| masterChain.getChain() == null \|\| masterChain.getChain().getEndBlockHeader() == null) { return 0L; } return masterChain.getChain().getEndBlockHeader().getHeight(); } ChainManager(); void newOrphanChain(Block block); boolean checkIsBeforeOrphanChainAndAdd(Block block); boolean checkIsAfterOrphanChainAndAdd(Block block); long getBestBlockHeight(); void clear(); ChainContainer getMasterChain(); void setMasterChain(ChainContainer masterChain); List<ChainContainer> getChains(); Block getBestBlock(); List<ChainContainer> getOrphanChains(); }### Answer: @Test public void testGetBestBlockHeight() { assertNotNull(chainManager); Block block = createBlock(); ChainContainer masterChain = new ChainContainer(new Chain()); chainManager.setMasterChain(masterChain); masterChain.getChain().addBlock(block); assertEquals(0L, chainManager.getBestBlockHeight()); }
### Question: ChainManager { public boolean checkIsBeforeOrphanChainAndAdd(Block block) { BlockHeader header = block.getHeader(); boolean success = false; for(ChainContainer chainContainer : orphanChains) { Chain chain = chainContainer.getChain(); if(header.getHash().equals(chain.getStartBlockHeader().getPreHash())) { success = true; chain.addPreBlock(block); } } return success; } ChainManager(); void newOrphanChain(Block block); boolean checkIsBeforeOrphanChainAndAdd(Block block); boolean checkIsAfterOrphanChainAndAdd(Block block); long getBestBlockHeight(); void clear(); ChainContainer getMasterChain(); void setMasterChain(ChainContainer masterChain); List<ChainContainer> getChains(); Block getBestBlock(); List<ChainContainer> getOrphanChains(); }### Answer: @Test public void testCheckIsBeforeOrphanChainAndAdd() { testGetBestBlockHeight(); Block block = createBlock(); Block block1 = createBlock(); block1.getHeader().setHeight(1L); block1.getHeader().setPreHash(block.getHeader().getHash()); ChainContainer orphanChain = new ChainContainer(new Chain()); orphanChain.getChain().addBlock(block1); chainManager.getOrphanChains().add(orphanChain); assertEquals(1, chainManager.getOrphanChains().size()); boolean success = chainManager.checkIsBeforeOrphanChainAndAdd(block); assertTrue(success); }
### Question: ChainManager { public boolean checkIsAfterOrphanChainAndAdd(Block block) { BlockHeader header = block.getHeader(); for(ChainContainer chainContainer : orphanChains) { Chain chain = chainContainer.getChain(); if(header.getPreHash().equals(chain.getEndBlockHeader().getHash())) { chain.addBlock(block); return true; } } return false; } ChainManager(); void newOrphanChain(Block block); boolean checkIsBeforeOrphanChainAndAdd(Block block); boolean checkIsAfterOrphanChainAndAdd(Block block); long getBestBlockHeight(); void clear(); ChainContainer getMasterChain(); void setMasterChain(ChainContainer masterChain); List<ChainContainer> getChains(); Block getBestBlock(); List<ChainContainer> getOrphanChains(); }### Answer: @Test public void testCheckIsAfterOrphanChainAndAdd() { testGetBestBlockHeight(); Block block = createBlock(); Block block1 = createBlock(); block1.getHeader().setHeight(1L); block1.getHeader().setPreHash(block.getHeader().getHash()); ChainContainer orphanChain = new ChainContainer(new Chain()); orphanChain.getChain().addBlock(block); chainManager.getOrphanChains().add(orphanChain); assertEquals(1, chainManager.getOrphanChains().size()); boolean success = chainManager.checkIsAfterOrphanChainAndAdd(block1); assertTrue(success); }
### Question: RoundManager { public void addRound(MeetingRound meetingRound) { roundList.add(meetingRound); } RoundManager(Chain chain); MeetingRound getRoundByIndex(long roundIndex); void addRound(MeetingRound meetingRound); void checkIsNeedReset(); boolean clearRound(int count); MeetingRound getCurrentRound(); MeetingRound initRound(); MeetingRound resetRound(boolean isRealTime); MeetingRound getNextRound(BlockExtendsData roundData, boolean isRealTime); Chain getChain(); List<MeetingRound> getRoundList(); AccountService getAccountService(); }### Answer: @Test public void testAddRound() { assertNotNull(roundManager); assertNotNull(roundManager.getChain()); assertEquals(0, roundManager.getRoundList().size()); MeetingRound round = new MeetingRound(); roundManager.addRound(round); assertEquals(1, roundManager.getRoundList().size()); assertEquals(round, roundManager.getCurrentRound()); MeetingRound round2 = new MeetingRound(); roundManager.addRound(round2); assertEquals(2, roundManager.getRoundList().size()); assertNotEquals(round, roundManager.getCurrentRound()); assertEquals(round2, roundManager.getCurrentRound()); }
### Question: Attribute implements Cloneable, Matchable<Attribute<?>> { public T get() { return value; } Attribute(AttributeDefinition<T> definition); String name(); T get(); T getInitialValue(); void validate(); Attribute<T> protect(); void set(T value); T computeIfAbsent(Supplier<T> supplier); boolean isImmutable(); boolean isPersistent(); boolean isModified(); K asObject(); void addListener(AttributeListener<T> listener); void removeListener(AttributeListener<T> listener); boolean isNull(); AttributeDefinition<T> getAttributeDefinition(); void read(Attribute<T> other); @Override int hashCode(); @Override boolean equals(Object obj); boolean matches(Attribute<?> other); @Override String toString(); void reset(); }### Answer: @Test public void testAttributeInitializer() { AttributeDefinition<Properties> def = AttributeDefinition.builder("props", null, Properties.class).initializer(new AttributeInitializer<Properties>() { @Override public Properties initialize() { return new Properties(); } }).build(); Attribute<Properties> attribute1 = def.toAttribute(); Attribute<Properties> attribute2 = def.toAttribute(); assertTrue(attribute1.get() != attribute2.get()); }
### Question: KeyTransformationHandler { public Object stringToKey(String s) { char type = s.charAt(0); switch (type) { case 'S': return s.substring(2); case 'I': return Integer.valueOf(s.substring(2)); case 'Y': return Byte.valueOf(s.substring(2)); case 'L': return Long.valueOf(s.substring(2)); case 'X': return Short.valueOf(s.substring(2)); case 'D': return Double.valueOf(s.substring(2)); case 'F': return Float.valueOf(s.substring(2)); case 'B': return Boolean.valueOf(s.substring(2)); case 'C': return Character.valueOf(s.charAt(2)); case 'U': return UUID.fromString(s.substring(2)); case 'A': return Base64.getDecoder().decode(s.substring(2)); case 'T': int indexOfSecondDelimiter = s.indexOf(':', 2); String keyClassName = s.substring(2, indexOfSecondDelimiter); String keyAsString = s.substring(indexOfSecondDelimiter + 1); Transformer t = getTransformer(keyClassName); if (t != null) { return t.fromString(keyAsString); } else { throw CONTAINER.noTransformerForKey(keyClassName); } } throw new CacheException("Unknown key type metadata: " + type); } KeyTransformationHandler(ClassLoader classLoader); Object stringToKey(String s); String keyToString(Object key); void registerTransformer(Class<?> keyClass, Class<? extends Transformer> transformerClass); }### Answer: @Test(expectedExceptions = CacheException.class) public void testStringToUnknownKey() { keyTransformationHandler.stringToKey("Z:someKey"); } @Test(expectedExceptions = CacheException.class) public void testStringToKeyWithInvalidTransformer() { keyTransformationHandler.stringToKey("T:org.infinispan.InexistentTransformer:key1"); }
### Question: KeyTransformationHandler { public String keyToString(Object key) { if (key instanceof byte[]) return "A:" + Base64.getEncoder().encodeToString((byte[]) key); if (key instanceof String) return "S:" + key; else if (key instanceof Integer) return "I:" + key; else if (key instanceof Boolean) return "B:" + key; else if (key instanceof Long) return "L:" + key; else if (key instanceof Float) return "F:" + key; else if (key instanceof Double) return "D:" + key; else if (key instanceof Short) return "X:" + key; else if (key instanceof Byte) return "Y:" + key; else if (key instanceof Character) return "C:" + key; else if (key instanceof UUID) return "U:" + key; else { Transformer t = getTransformer(key.getClass()); if (t != null) { return "T:" + key.getClass().getName() + ":" + t.toString(key); } else { throw CONTAINER.noTransformerForKey(key.getClass().getName()); } } } KeyTransformationHandler(ClassLoader classLoader); Object stringToKey(String s); String keyToString(Object key); void registerTransformer(Class<?> keyClass, Class<? extends Transformer> transformerClass); }### Answer: @Test(expectedExceptions = IllegalArgumentException.class) public void testKeyToStringWithDefaultTransformerForNonSerializableObject() { NonSerializableKey key = new NonSerializableKey("test"); keyTransformationHandler.keyToString(key); }
### Question: EmptyIntSet extends AbstractImmutableIntSet { @Override public boolean containsAll(IntSet set) { return set.isEmpty(); } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testContainsAll1() throws Exception { Set<Integer> hashSet = new HashSet<>(); hashSet.add(3); assertFalse(es.containsAll(hashSet)); assertTrue(hashSet.containsAll(es)); hashSet.remove(3); assertTrue(hashSet.containsAll(es)); assertTrue(es.containsAll(hashSet)); } @Test public void testContainsAll() throws Exception { IntSet sis2 = new SingletonIntSet(3); assertFalse(es.containsAll(sis2)); assertTrue(sis2.containsAll(es)); IntSet sis3 = new RangeSet(0); assertTrue(sis3.containsAll(es)); assertTrue(es.containsAll(sis3)); }
### Question: HibernateSearchPropertyHelper extends ReflectionPropertyHelper { @Override public IndexedFieldProvider<Class<?>> getIndexedFieldProvider() { return entityType -> { IndexDescriptor indexDescriptor = getIndexDescriptor(entityType); if (indexDescriptor == null) { return IndexedFieldProvider.NO_INDEXING; } return new SearchFieldIndexingMetadata(indexDescriptor); }; } HibernateSearchPropertyHelper(SearchMapping searchMapping, EntityNameResolver<Class<?>> entityNameResolver); @Override Object convertToPropertyType(Class<?> entityType, String[] propertyPath, String value); @Override Class<?> getPrimitivePropertyType(Class<?> entityType, String[] propertyPath); @Override boolean isRepeatedProperty(Class<?> entityType, String[] propertyPath); @Override boolean hasEmbeddedProperty(Class<?> entityType, String[] propertyPath); @Override boolean hasProperty(Class<?> entityType, String[] propertyPath); @Override IndexedFieldProvider<Class<?>> getIndexedFieldProvider(); static String KEY; static String VALUE; }### Answer: @Test public void testRecognizeAnalyzedField() { assertThat(propertyHelper.getIndexedFieldProvider().get(TestEntity.class).isAnalyzed(new String[]{"description"})).isTrue(); } @Test public void testRecognizeStoredField() { assertThat(propertyHelper.getIndexedFieldProvider().get(TestEntity.class).isStored(new String[]{"description"})).isTrue(); } @Test public void testRecognizeUnanalyzedField() { assertThat(propertyHelper.getIndexedFieldProvider().get(TestEntity.class).isAnalyzed(new String[]{"i"})).isFalse(); }
### Question: Interval { public boolean contains(K value) { return (includeLower ? low.compareTo(value) <= 0 : low.compareTo(value) < 0) && (includeUpper ? up.compareTo(value) >= 0 : up.compareTo(value) > 0); } Interval(K low, boolean includeLower, K up, boolean includeUpper); static K getMinusInf(); static K getPlusInf(); boolean contains(K value); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); final K low; final boolean includeLower; final K up; final boolean includeUpper; }### Answer: @Test public void testContains() { assertTrue(new Interval(Interval.<Integer>getMinusInf(), false, 1000, false).contains(20)); assertFalse(new Interval(Interval.<Integer>getMinusInf(), false, 1000, false).contains(1000)); assertFalse(new Interval(Interval.<Integer>getMinusInf(), false, 1000, false).contains(1001)); assertTrue(new Interval(1000, false, Interval.<Integer>getPlusInf(), false).contains(2000)); assertFalse(new Interval(1000, false, Interval.<Integer>getPlusInf(), false).contains(1000)); assertFalse(new Interval(1000, false, Interval.<Integer>getPlusInf(), false).contains(999)); }
### Question: DoubleStat { Double getSum() { if (count == 0) { return null; } double tmp = sum + sumCompensation; if (Double.isNaN(tmp) && Double.isInfinite(simpleSum)) { return simpleSum; } else { return tmp; } } }### Answer: @Test public void testEmptySum() { DoubleStat sum = new DoubleStat(); assertNull(sum.getSum()); }
### Question: DoubleStat { Double getAvg() { return count == 0 ? null : getSum() / count; } }### Answer: @Test public void testEmptyAvg() { DoubleStat avg = new DoubleStat(); assertNull(avg.getAvg()); }
### Question: EmptyIntSet extends AbstractImmutableIntSet { @Override public IntStream intStream() { return IntStream.empty(); } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testIntStream() throws Exception { assertEquals(0, es.intStream().count()); }
### Question: EmptyIntSet extends AbstractImmutableIntSet { @Override public boolean equals(Object obj) { if (obj instanceof Set) { return ((Set) obj).size() == 0; } return false; } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testEquals() throws Exception { IntSet sis2 = new SingletonIntSet(4); assertNotEquals(es, sis2); assertNotEquals(sis2, es); IntSet sis3 = new SmallIntSet(2); assertEquals(sis3, es); assertEquals(es, sis3); }
### Question: L1ConfigurationBuilder extends AbstractClusteringConfigurationChildBuilder implements Builder<L1Configuration>, ConfigurationBuilderInfo { public L1ConfigurationBuilder enable() { attributes.attribute(ENABLED).set(true); return this; } L1ConfigurationBuilder(ClusteringConfigurationBuilder builder); @Override ElementDefinition getElementDefinition(); @Override AttributeSet attributes(); L1ConfigurationBuilder invalidationThreshold(int invalidationThreshold); L1ConfigurationBuilder lifespan(long lifespan); L1ConfigurationBuilder lifespan(long lifespan, TimeUnit unit); L1ConfigurationBuilder cleanupTaskFrequency(long frequencyMillis); L1ConfigurationBuilder cleanupTaskFrequency(long frequencyMillis, TimeUnit unit); L1ConfigurationBuilder enable(); L1ConfigurationBuilder disable(); L1ConfigurationBuilder enabled(boolean enabled); @Override void validate(); @Override void validate(GlobalConfiguration globalConfig); @Override L1Configuration create(); @Override L1ConfigurationBuilder read(L1Configuration template); @Override String toString(); }### Answer: @Test(expectedExceptions = CacheConfigurationException.class) public void testL1WithExceptionEviction() { Configuration config = new ConfigurationBuilder() .clustering() .cacheMode(CacheMode.DIST_SYNC) .l1().enable() .memory() .evictionStrategy(EvictionStrategy.EXCEPTION) .size(10) .transaction() .transactionMode(org.infinispan.transaction.TransactionMode.TRANSACTIONAL) .build(); assertNotNull(config); }
### Question: DependencyGraph { public void removeDependency(T from, T to) { lock.writeLock().lock(); try { Set<T> dependencies = outgoingEdges.get(from); if (dependencies == null \|\| !dependencies.contains(to)) { throw new IllegalArgumentException("Inexistent dependency"); } dependencies.remove(to); incomingEdges.get(to).remove(from); } finally { lock.writeLock().unlock(); } } List<T> topologicalSort(); void addDependency(T from, T to); void removeDependency(T from, T to); void clearAll(); boolean hasDependent(T element); Set<T> getDependents(T element); void remove(T element); }### Answer: @Test public void testRemoveDependency() throws CyclicDependencyException { DependencyGraph<String> g = new DependencyGraph<>(); g.addDependency("E", "B"); g.addDependency("E", "C"); g.addDependency("E", "D"); g.addDependency("B", "D"); g.addDependency("B", "C"); g.addDependency("C", "D"); assertEquals(g.topologicalSort(), Arrays.asList("E", "B", "C", "D")); g.removeDependency("E", "B"); g.addDependency("B", "E"); assertEquals(g.topologicalSort(), Arrays.asList("B", "E", "C", "D")); g.clearAll(); assertTrue(g.topologicalSort().isEmpty()); }
### Question: DependencyGraph { public void addDependency(T from, T to) { if (from == null \|\| to == null \|\| from.equals(to)) { throw new IllegalArgumentException("Invalid parameters"); } lock.writeLock().lock(); try { if (addOutgoingEdge(from, to)) { addIncomingEdge(to, from); } } finally { lock.writeLock().unlock(); } } List<T> topologicalSort(); void addDependency(T from, T to); void removeDependency(T from, T to); void clearAll(); boolean hasDependent(T element); Set<T> getDependents(T element); void remove(T element); }### Answer: @Test(expectedExceptions = IllegalArgumentException.class) public void testAddSelf() { new DependencyGraph<>().addDependency("N", "N"); } @Test(expectedExceptions = IllegalArgumentException.class) public void testAdNull() { new DependencyGraph<>().addDependency("N", null); }
### Question: EmptyIntSet extends AbstractImmutableIntSet { @Override public int size() { return 0; } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testForEachPrimitive() { Set<Integer> results = new HashSet<>(); es.forEach((IntConsumer) results::add); assertEquals(0, results.size()); } @Test public void testForEachObject() { Set<Integer> results = new HashSet<>(); es.forEach((Consumer<? super Integer>) results::add); assertEquals(0, results.size()); } @Test public void testIntSpliteratorForEachRemaining() { Set<Integer> results = new HashSet<>(); es.intSpliterator().forEachRemaining((IntConsumer) results::add); assertEquals(0, results.size()); } @Test public void testIntSpliteratorSplitTryAdvance() { Set<Integer> results = new HashSet<>(); Spliterator.OfInt spliterator = es.intSpliterator(); Spliterator.OfInt split = spliterator.trySplit(); assertNull(split); IntConsumer consumer = results::add; while (spliterator.tryAdvance(consumer)) { } assertEquals(0, results.size()); } @Test public void testSize() { assertEquals(0, es.size()); }
### Question: QueueAsyncInvocationStage extends SimpleAsyncInvocationStage implements BiConsumer<Object, Throwable>, InvocationCallback { InvocationCallback queuePoll() { InvocationCallback element; synchronized (this) { if (tail != head) { element = elements[head & mask]; head++; } else { element = null; frozen = true; } } return element; } QueueAsyncInvocationStage(InvocationContext ctx, VisitableCommand command, CompletableFuture<?> valueFuture, InvocationCallback function); @Override Object addCallback(InvocationContext ctx, VisitableCommand command, InvocationCallback function); @Override void accept(Object rv, Throwable throwable); @Override Object apply(InvocationContext rCtx, VisitableCommand rCommand, Object rv, Throwable throwable); @Override String toString(); }### Answer: @Test(dataProvider = "offsets") public void testExpandCapacity(int splitOffset) throws Throwable { CompletableFuture<Object> future = new CompletableFuture<>(); QueueAsyncInvocationStage stage = new QueueAsyncInvocationStage(null, null, future, makeCallback(0)); assertCallback(0, stage.queuePoll()); addAndPoll(stage, splitOffset); int count = 2 * QueueAsyncInvocationStage.QUEUE_INITIAL_CAPACITY; addAndPoll(stage, count); }
### Question: UnpooledOffHeapMemoryAllocator implements OffHeapMemoryAllocator { public static long estimateSizeOverhead(long size) { return (size + 8 + 15) & ~15; } @Override long allocate(long memoryLength); @Override void deallocate(long memoryAddress, long size); @Override long getAllocatedAmount(); static long estimateSizeOverhead(long size); static long offHeapEntrySize(boolean evictionEnabled, boolean writeMetadataSize, int keySize, int valueSize); static long offHeapEntrySize(boolean evictionEnabled, boolean writeMetadataSize, int keySize, int valueSize, int metadataSize, int internalMetadataSize); }### Answer: @Test(dataProvider = "roundings") public void testRoundings(long original, long expected) { assertEquals(expected, UnpooledOffHeapMemoryAllocator.estimateSizeOverhead(original)); }
### Question: StringPropertyReplacer { public static String replaceProperties(final String string) { return replaceProperties(string, null); } static String replaceProperties(final String string); static String replaceProperties(final String string, final Properties props); static void replaceProperties(Map<String, String> map, Properties properties); static final String NEWLINE; }### Answer: @Test public void testReplaceProperties() { Properties properties = new Properties(); properties.put("one", "1"); properties.put("two", "2"); assertEquals("V1", StringPropertyReplacer.replaceProperties("V${one}", properties)); assertEquals("VX", StringPropertyReplacer.replaceProperties("V${void:X}", properties)); assertEquals("V1", StringPropertyReplacer.replaceProperties("V${void,one}", properties)); assertEquals("VX", StringPropertyReplacer.replaceProperties("V${void1,void2:X}", properties)); assertEquals(System.getenv("PATH"), StringPropertyReplacer.replaceProperties("${env.PATH}", properties)); assertEquals(File.separator, StringPropertyReplacer.replaceProperties("${/}")); assertEquals(File.pathSeparator, StringPropertyReplacer.replaceProperties("${:}")); }
### Question: XSiteResource implements ResourceHandler { private CompletionStage<RestResponse> backupStatus(RestRequest request) { return statusOperation(request, SITES_STATUS); } XSiteResource(InvocationHelper invocationHelper); @Override Invocations getInvocations(); static final String AFTER_FAILURES_FIELD; static final String MIN_WAIT_FIELD; }### Answer: @Test public void testInvalidSite() { RestClient client = clientPerSite.get(LON); RestCacheClient cache = client.cache(CACHE_1); assertStatus(404, cache.backupStatus("invalid-site")); }
### Question: XSiteResource implements ResourceHandler { private CompletionStage<RestResponse> cancelPushState(RestRequest restRequest) { return executeXSiteCacheOp(restRequest, CANCEL_PUSH_STATE); } XSiteResource(InvocationHelper invocationHelper); @Override Invocations getInvocations(); static final String AFTER_FAILURES_FIELD; static final String MIN_WAIT_FIELD; }### Answer: @Test public void testCancelPushState() throws Exception { RestCacheClient cache = getCacheClient(LON); RestCacheClient backupCache = getCacheClient(NYC); takeBackupOffline(LON, NYC); assertEquals(OFFLINE, getBackupStatus(LON, NYC)); int entries = 50; IntStream.range(0, entries).forEach(i -> assertNoContent(cache.put(String.valueOf(i), "value"))); assertEquals(entries, getCacheSize(cache)); assertEquals(0, getCacheSize(backupCache)); ControlledTransport controllerTransport = ControlledTransport.replace(cache(LON, 0)); controllerTransport.blockBefore(XSiteStatePushCommand.class); assertSuccessful(cache.pushSiteState(NYC)); controllerTransport.waitForCommandToBlock(); assertSuccessful(cache.cancelPushState(NYC)); controllerTransport.stopBlocking(); Json status = jsonResponseBody(cache.pushStateStatus()); assertEquals("CANCELED", status.at(NYC).asString()); assertSuccessful(cache.clearPushStateStatus()); status = jsonResponseBody(cache.pushStateStatus()); assertTrue(status.asMap().isEmpty()); assertSuccessful(cache.cancelReceiveState(NYC)); }
### Question: RangeSet implements IntSet { @Override public int size() { return size; } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testSize() { RangeSet rs = new RangeSet(4); assertEquals(4, rs.size()); }
### Question: RangeSet implements IntSet { @Override public boolean isEmpty() { return size <= 0; } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testIsEmpty() { RangeSet rs = new RangeSet(0); assertTrue(rs.isEmpty()); rs = new RangeSet(3); assertFalse(rs.isEmpty()); }
### Question: ServiceFinder { public static <T> Collection<T> load(Class<T> contract, ClassLoader... loaders) { Map<String, T> services = new LinkedHashMap<>(); if (loaders.length == 0) { try { ServiceLoader<T> loadedServices = ServiceLoader.load(contract); addServices(loadedServices, services); } catch (Exception e) { } } else { for (ClassLoader loader : loaders) { if (loader == null) throw new NullPointerException(); try { ServiceLoader<T> loadedServices = ServiceLoader.load(contract, loader); addServices(loadedServices, services); } catch (Exception e) { } } } if (services.isEmpty()) { LOG.debugf("No service impls found: %s", contract.getSimpleName()); } return services.values(); } static Collection<T> load(Class<T> contract, ClassLoader... loaders); }### Answer: @Test public void testDuplicateServiceFinder() { ClassLoader mainClassLoader = this.getClass().getClassLoader(); ClassLoader otherClassLoader = new ClonedClassLoader(mainClassLoader); Collection<SampleSPI> spis = ServiceFinder.load(SampleSPI.class, mainClassLoader, otherClassLoader); assertEquals(1, spis.size()); }
### Question: RestRouteSource implements PrefixedRouteSource { @Override public void validate() { if (pathPrefix == null \|\| !pathPrefix.matches("\\w+")) { throw new IllegalArgumentException("Path is incorrect"); } } RestRouteSource(String pathPrefix); @Override String getRoutePrefix(); @Override String toString(); @Override void validate(); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldValidatePath() { new RestRouteSource(null).validate(); } @Test(expected = IllegalArgumentException.class) public void shouldValidateWithWhiteCharacters() { new RestRouteSource("12312 234").validate(); } @Test(expected = IllegalArgumentException.class) public void shouldValidateStartingSlash() { new RestRouteSource("/test").validate(); } @Test public void shouldPassOnCorrectPath() { new RestRouteSource("correctPath").validate(); }
### Question: RestServerRouteDestination implements RouteDestination { @Override public void validate() { if (name == null \|\| "".equals(name)) { throw new IllegalArgumentException("Name can not be null"); } if (restServer == null) { throw new IllegalArgumentException("REST resource can not be null"); } } RestServerRouteDestination(String name, RestServer restServer); String getName(); RestServer getRestServer(); @Override String toString(); @Override void validate(); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldValidateName() { new RestServerRouteDestination(null, new RestServer()).validate(); } @Test(expected = IllegalArgumentException.class) public void shouldValidateRestResource() { new RestServerRouteDestination("test", null).validate(); }
### Question: SniNettyRouteSource implements SniRouteSource { @Override public void validate() { if (sniHostName == null \|\| "".equals(sniHostName)) { throw new IllegalArgumentException("SNI Host name can not be null"); } if (jdkContext == null) { throw new IllegalArgumentException("JDK SSL Context must not be null"); } } SniNettyRouteSource(String sniHostName, SSLContext sslContext); SniNettyRouteSource(String sniHostName, String keyStoreFileName, char[] keyStorePassword); @Override SSLContext getSslContext(); @Override String getSniHostName(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); @Override void validate(); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldValidateSniHostName() throws Exception { new SniNettyRouteSource(null, SSLContext.getDefault()).validate(); } @Test(expected = IllegalArgumentException.class) public void shouldValidateSSLContext() throws Exception { new SniNettyRouteSource("test", null).validate(); }
### Question: HotRodServerRouteDestination implements RouteDestination { @Override public void validate() { if (name == null \|\| "".equals(name)) { throw new IllegalArgumentException("Name can not be null"); } if (hotrodServer == null) { throw new IllegalArgumentException("Channels can not be null"); } } HotRodServerRouteDestination(String name, HotRodServer hotRodServer); HotRodServer getHotrodServer(); @Override String toString(); @Override void validate(); }### Answer: @Test(expected = IllegalArgumentException.class) public void shouldValidateName() { new HotRodServerRouteDestination(null, new HotRodServer()).validate(); } @Test(expected = IllegalArgumentException.class) public void shouldValidateChannelInitializer() { new HotRodServerRouteDestination("test", null).validate(); }
### Question: RangeSet implements IntSet { @Override public boolean contains(Object o) { if (!(o instanceof Integer)) return false; int i = (int) o; return contains(i); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void contains() throws Exception { RangeSet rs = new RangeSet(4); assertFalse(rs.contains(5)); assertTrue(rs.contains(1)); } @Test public void contains1() throws Exception { RangeSet rs = new RangeSet(4); assertFalse(rs.contains(Integer.valueOf(5))); assertTrue(rs.contains(Integer.valueOf(1))); }
### Question: SpringEmbeddedCacheManager implements CacheManager { public EmbeddedCacheManager getNativeCacheManager() { return this.nativeCacheManager; } SpringEmbeddedCacheManager(final EmbeddedCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); EmbeddedCacheManager getNativeCacheManager(); void stop(); }### Answer: @Test public final void getNativeCacheShouldReturnTheEmbeddedCacheManagerSuppliedAtConstructionTime() { withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.createCacheManager()) { @Override public void call() { final SpringEmbeddedCacheManager objectUnderTest = new SpringEmbeddedCacheManager(cm); final EmbeddedCacheManager nativeCacheManagerReturned = objectUnderTest.getNativeCacheManager(); assertSame( "getNativeCacheManager() should have returned the EmbeddedCacheManager supplied at construction time. However, it retuned a different one.", cm, nativeCacheManagerReturned); } }); }
### Question: SpringEmbeddedCacheManager implements CacheManager { @Override public SpringCache getCache(final String name) { return springCaches.computeIfAbsent(name, n -> { final Cache<Object, Object> nativeCache = this.nativeCacheManager.getCache(n); return new SpringCache(nativeCache); }); } SpringEmbeddedCacheManager(final EmbeddedCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); EmbeddedCacheManager getNativeCacheManager(); void stop(); }### Answer: @Test public final void getCacheShouldReturnSameInstanceForSameName() { withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.createCacheManager()) { @Override public void call() { cm.defineConfiguration("same", new ConfigurationBuilder().build()); final SpringEmbeddedCacheManager objectUnderTest = new SpringEmbeddedCacheManager(cm); final String sameCacheName = "same"; final SpringCache firstObtainedSpringCache = objectUnderTest.getCache(sameCacheName); final SpringCache secondObtainedSpringCache = objectUnderTest.getCache(sameCacheName); assertSame( "getCache() should have returned the same SpringCache instance for the same name", firstObtainedSpringCache, secondObtainedSpringCache); } }); } @Test public final void getCacheShouldReturnDifferentInstancesForDifferentNames() { withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.createCacheManager()) { @Override public void call() { cm.defineConfiguration("thisCache", new ConfigurationBuilder().build()); cm.defineConfiguration("thatCache", new ConfigurationBuilder().build()); final SpringEmbeddedCacheManager objectUnderTest = new SpringEmbeddedCacheManager(cm); final String firstCacheName = "thisCache"; final String secondCacheName = "thatCache"; final SpringCache firstObtainedSpringCache = objectUnderTest.getCache(firstCacheName); final SpringCache secondObtainedSpringCache = objectUnderTest.getCache(secondCacheName); assertNotSame( "getCache() should have returned different SpringCache instances for different names", firstObtainedSpringCache, secondObtainedSpringCache); } }); }
### Question: SpringEmbeddedCacheManagerFactoryBean extends AbstractEmbeddedCacheManagerFactory implements FactoryBean<SpringEmbeddedCacheManager>, InitializingBean, DisposableBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override SpringEmbeddedCacheManager getObject(); @Override Class<? extends SpringEmbeddedCacheManager> getObjectType(); @Override boolean isSingleton(); @Override void destroy(); }### Answer: @Test public void testIfSpringEmbeddedCacheManagerFactoryBeanDeclaresItselfToOnlyProduceSingletons() { objectUnderTest = new SpringEmbeddedCacheManagerFactoryBean(); assertTrue("isSingleton() should always return true. However, it returned false", objectUnderTest.isSingleton()); }
### Question: InfinispanNamedEmbeddedCacheFactoryBean implements FactoryBean<Cache<K, V>>, BeanNameAware, InitializingBean, DisposableBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override Cache<K, V> getObject(); @Override Class<? extends Cache> getObjectType(); @Override boolean isSingleton(); @Override void setBeanName(final String name); @Override void destroy(); void setCacheName(final String cacheName); void setInfinispanEmbeddedCacheManager( final EmbeddedCacheManager infinispanEmbeddedCacheManager); void setConfigurationTemplateMode(final String configurationTemplateMode); void addCustomConfiguration(final ConfigurationBuilder builder); }### Answer: @Test public final void infinispanNamedEmbeddedCacheFactoryBeanShouldDeclareItselfToBeSingleton() { final InfinispanNamedEmbeddedCacheFactoryBean<Object, Object> objectUnderTest = new InfinispanNamedEmbeddedCacheFactoryBean<Object, Object>(); assertTrue( "InfinispanNamedEmbeddedCacheFactoryBean should declare itself to produce a singleton. However, it didn't.", objectUnderTest.isSingleton()); }
### Question: InfinispanEmbeddedCacheManagerFactoryBean extends AbstractEmbeddedCacheManagerFactory implements FactoryBean<EmbeddedCacheManager>, InitializingBean, DisposableBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override EmbeddedCacheManager getObject(); @Override Class<? extends EmbeddedCacheManager> getObjectType(); @Override boolean isSingleton(); @Override void destroy(); }### Answer: @Test public final void infinispanEmbeddedCacheManagerFactoryBeanShouldDeclareItselfToOnlyProduceSingletons() { final InfinispanEmbeddedCacheManagerFactoryBean objectUnderTest = new InfinispanEmbeddedCacheManagerFactoryBean(); assertTrue("isSingleton() should always return true. However, it returned false", objectUnderTest.isSingleton()); }
### Question: SpringRemoteCacheManagerFactoryBean extends AbstractRemoteCacheManagerFactory implements FactoryBean<SpringRemoteCacheManager>, InitializingBean, DisposableBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override SpringRemoteCacheManager getObject(); @Override Class<? extends SpringRemoteCacheManager> getObjectType(); @Override boolean isSingleton(); @Override void destroy(); }### Answer: @Test public final void isSingletonShouldAlwaysReturnTrue() { objectUnderTest = new SpringRemoteCacheManagerFactoryBean(); assertTrue( "isSingleton() should always return true since each SpringRemoteCacheManagerFactoryBean will always produce " + "the same SpringRemoteCacheManager instance. However,it returned false.", objectUnderTest.isSingleton()); }
### Question: RangeSet implements IntSet { @Override public PrimitiveIterator.OfInt iterator() { return new RangeSetIterator(size); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void iterator() throws Exception { RangeSet rs = new RangeSet(4); PrimitiveIterator.OfInt iterator = rs.iterator(); assertEquals(0, iterator.nextInt()); assertEquals(1, iterator.nextInt()); assertEquals(2, iterator.nextInt()); assertEquals(3, iterator.nextInt()); }
### Question: SpringRemoteCacheManager implements org.springframework.cache.CacheManager { @Override public Collection<String> getCacheNames() { return this.nativeCacheManager.getCacheNames(); } SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager, long readTimeout, long writeTimeout); SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); RemoteCacheManager getNativeCacheManager(); long getReadTimeout(); long getWriteTimeout(); void setReadTimeout(final long readTimeout); void setWriteTimeout(final long writeTimeout); void start(); void stop(); }### Answer: @Test public final void getCacheNamesShouldReturnAllCachesDefinedInConfigurationFile() { final Collection<String> cacheNames = objectUnderTest.getCacheNames(); assertTrue("SpringRemoteCacheManager should load all named caches found in the " + "native cache manager. However, it does not know about the cache named " + TEST_CACHE_NAME + " defined in said cache manager.", cacheNames.contains(TEST_CACHE_NAME)); }
### Question: SpringRemoteCacheManager implements org.springframework.cache.CacheManager { public void start() { this.nativeCacheManager.start(); } SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager, long readTimeout, long writeTimeout); SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); RemoteCacheManager getNativeCacheManager(); long getReadTimeout(); long getWriteTimeout(); void setReadTimeout(final long readTimeout); void setWriteTimeout(final long writeTimeout); void start(); void stop(); }### Answer: @Test public final void startShouldStartTheNativeRemoteCacheManager() throws IOException { objectUnderTest.start(); assertTrue("Calling start() on SpringRemoteCacheManager should start the enclosed " + "Infinispan RemoteCacheManager. However, it is still not running.", remoteCacheManager.isStarted()); }
### Question: SpringRemoteCacheManager implements org.springframework.cache.CacheManager { public void stop() { this.nativeCacheManager.stop(); this.springCaches.clear(); } SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager, long readTimeout, long writeTimeout); SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); RemoteCacheManager getNativeCacheManager(); long getReadTimeout(); long getWriteTimeout(); void setReadTimeout(final long readTimeout); void setWriteTimeout(final long writeTimeout); void start(); void stop(); }### Answer: @Test public final void stopShouldStopTheNativeRemoteCacheManager() throws IOException { objectUnderTest.stop(); assertFalse("Calling stop() on SpringRemoteCacheManager should stop the enclosed " + "Infinispan RemoteCacheManager. However, it is still running.", remoteCacheManager.isStarted()); }
### Question: SpringRemoteCacheManager implements org.springframework.cache.CacheManager { public RemoteCacheManager getNativeCacheManager() { return this.nativeCacheManager; } SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager, long readTimeout, long writeTimeout); SpringRemoteCacheManager(final RemoteCacheManager nativeCacheManager); @Override SpringCache getCache(final String name); @Override Collection<String> getCacheNames(); RemoteCacheManager getNativeCacheManager(); long getReadTimeout(); long getWriteTimeout(); void setReadTimeout(final long readTimeout); void setWriteTimeout(final long writeTimeout); void start(); void stop(); }### Answer: @Test public final void getNativeCacheShouldReturnTheRemoteCacheManagerSuppliedAtConstructionTime() { final RemoteCacheManager nativeCacheManagerReturned = objectUnderTest.getNativeCacheManager(); assertSame( "getNativeCacheManager() should have returned the RemoteCacheManager supplied at construction time. However, it retuned a different one.", remoteCacheManager, nativeCacheManagerReturned); }
### Question: ConfigurationPropertiesOverrides { public boolean isEmpty() { return this.overridingProperties.isEmpty(); } boolean isEmpty(); @Deprecated void setTransportFactory(final String TransportFactory); void setServerList(final Collection<InetSocketAddress> serverList); void setMarshaller(final String marshaller); void setClassAllowList(final String allowListRegex); void setAsyncExecutorFactory(final String asyncExecutorFactory); void setTcpNoDelay(final boolean tcpNoDelay); void setTcpKeepAlive(final boolean tcpKeepAlive); void setRequestBalancingStrategy(final String requestBalancingStrategy); @Deprecated void setKeySizeEstimate(final int keySizeEstimate); @Deprecated void setValueSizeEstimate(final int valueSizeEstimate); void setForceReturnValues(final boolean forceReturnValues); void setReadTimeout(long readTimeout); void setWriteTimeout(long writeTimeout); void setNearCacheMode(String mode); void setNearCacheMaxEntries(int maxEntries); void setNearCacheNamePattern(String pattern); Properties override(final Properties configurationPropertiesToOverride); static final String OPERATION_READ_TIMEOUT; static final String OPERATION_WRITE_TIMEOUT; }### Answer: @Test public final void testIfIsEmptyRecognizesThatConfigurationPropertiesOverridesAreEmpty() { final ConfigurationPropertiesOverrides objectUnderTest = new ConfigurationPropertiesOverrides(); assertTrue( "isEmpty() should have noticed that the ConfigurationPropertiesOverrides instance is indeed empty. However, it didn't.", objectUnderTest.isEmpty()); }
### Question: InfinispanRemoteCacheManagerFactoryBean extends AbstractRemoteCacheManagerFactory implements FactoryBean<RemoteCacheManager>, InitializingBean, DisposableBean { @Override public void afterPropertiesSet() throws Exception { assertCorrectlyConfigured(); this.logger.info("Creating new instance of RemoteCacheManager ..."); final Properties configurationPropertiesToUse = configurationProperties(); org.infinispan.client.hotrod.configuration.ConfigurationBuilder clientBuilder = new org.infinispan.client.hotrod.configuration.ConfigurationBuilder(); clientBuilder.withProperties(configurationPropertiesToUse); this.nativeRemoteCacheManager = new RemoteCacheManager(clientBuilder.build(), this.startAutomatically); this.logger.info("Finished creating new instance of RemoteCacheManager"); } @Override void afterPropertiesSet(); @Override RemoteCacheManager getObject(); @Override Class<? extends RemoteCacheManager> getObjectType(); @Override boolean isSingleton(); @Override void destroy(); }### Answer: @Test(expectedExceptions = IllegalStateException.class) public final void shouldThrowAnIllegalStateExceptionIfBothConfigurationPropertiesAndConfigurationPropertiesFileLocationAreSet() throws Exception { final InfinispanRemoteCacheManagerFactoryBean objectUnderTest = new InfinispanRemoteCacheManagerFactoryBean(); objectUnderTest.setConfigurationProperties(new Properties()); objectUnderTest.setConfigurationPropertiesFileLocation(new ClassPathResource("dummy", getClass())); objectUnderTest.afterPropertiesSet(); } @Test(expectedExceptions = IllegalStateException.class) public final void shouldThrowAnIllegalStateExceptionIfConfigurationPropertiesAsWellAsSettersAreUsedToConfigureTheRemoteCacheManager() throws Exception { final InfinispanRemoteCacheManagerFactoryBean objectUnderTest = new InfinispanRemoteCacheManagerFactoryBean(); objectUnderTest.setConfigurationProperties(new Properties()); objectUnderTest.setMarshaller("test.Marshaller"); objectUnderTest.afterPropertiesSet(); }
### Question: RangeSet implements IntSet { @Override public Object[] toArray() { Object[] array = new Object[size]; for (int i = 0; i < size; i++) { array[i] = i; } return array; } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void toArray() throws Exception { RangeSet rs = new RangeSet(4); Object[] array = rs.toArray(); assertEquals(4, array.length); assertEquals(0, array[0]); assertEquals(1, array[1]); assertEquals(2, array[2]); assertEquals(3, array[3]); } @Test public void toArray1() throws Exception { RangeSet rs = new RangeSet(4); Object[] array = rs.toArray(new Integer[4]); assertEquals(4, array.length); assertEquals(0, array[0]); assertEquals(1, array[1]); assertEquals(2, array[2]); assertEquals(3, array[3]); }
### Question: InfinispanRemoteCacheManagerFactoryBean extends AbstractRemoteCacheManagerFactory implements FactoryBean<RemoteCacheManager>, InitializingBean, DisposableBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override RemoteCacheManager getObject(); @Override Class<? extends RemoteCacheManager> getObjectType(); @Override boolean isSingleton(); @Override void destroy(); }### Answer: @Test public final void isSingletonShouldAlwaysReturnTrue() { final InfinispanRemoteCacheManagerFactoryBean objectUnderTest = new InfinispanRemoteCacheManagerFactoryBean(); assertTrue( "isSingleton() should always return true since each AbstractRemoteCacheManagerFactory will always produce " + "the same RemoteCacheManager instance. However,it returned false.", objectUnderTest.isSingleton()); }
### Question: InfinispanNamedRemoteCacheFactoryBean implements FactoryBean<RemoteCache<K, V>>, BeanNameAware, InitializingBean { @Override public boolean isSingleton() { return true; } @Override void afterPropertiesSet(); @Override void setBeanName(final String name); @Override RemoteCache<K, V> getObject(); @Override Class<? extends ConcurrentMap> getObjectType(); @Override boolean isSingleton(); void setCacheName(final String cacheName); void setInfinispanRemoteCacheManager(final RemoteCacheManager infinispanRemoteCacheManager); }### Answer: @Test public final void infinispanNamedRemoteCacheFactoryBeanShouldDeclareItselfToBeSingleton() { final InfinispanNamedRemoteCacheFactoryBean<String, Object> objectUnderTest = new InfinispanNamedRemoteCacheFactoryBean<String, Object>(); assertTrue( "InfinispanNamedRemoteCacheFactoryBean should declare itself to produce a singleton. However, it didn't.", objectUnderTest.isSingleton()); }
### Question: RangeSet implements IntSet { @Override public int[] toIntArray() { int[] array = new int[size]; for (int i = 0; i < size; i++) { array[i] = i; } return array; } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void toIntArray() throws Exception { RangeSet rs = new RangeSet(4); int[] array = rs.toIntArray(); assertArrayEquals(new int[]{0, 1, 2, 3}, array); }
### Question: RangeSet implements IntSet { public void set(int i) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void set() throws Exception { RangeSet rs = new RangeSet(4); rs.set(1); }
### Question: RangeSet implements IntSet { @Override public boolean remove(Object o) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void remove() throws Exception { RangeSet rs = new RangeSet(4); rs.remove(1); } @Test(expected = UnsupportedOperationException.class) public void remove1() throws Exception { RangeSet rs = new RangeSet(4); rs.remove(Integer.valueOf(1)); }
### Question: RangeSet implements IntSet { @Override public boolean containsAll(Collection<?> c) { if (c instanceof IntSet) { return containsAll((IntSet) c); } for (Object o : c) { if (!contains(o)) return false; } return true; } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void containsAll() throws Exception { RangeSet rs = new RangeSet(4); RangeSet rs2 = new RangeSet(4); assertTrue(rs.containsAll(rs2)); RangeSet rs3 = new RangeSet(3); assertTrue(rs.containsAll(rs3)); assertFalse(rs3.containsAll(rs)); }
### Question: RangeSet implements IntSet { @Override public boolean addAll(IntSet set) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void addAll() throws Exception { RangeSet rs = new RangeSet(4); RangeSet rs2 = new RangeSet(5); rs.addAll(rs2); } @Test(expected = UnsupportedOperationException.class) public void addAll1() throws Exception { RangeSet rs = new RangeSet(4); SmallIntSet sis = new SmallIntSet(); rs.addAll(sis); }
### Question: RangeSet implements IntSet { @Override public boolean removeAll(IntSet set) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void removeAll() throws Exception { RangeSet rs = new RangeSet(4); RangeSet rs2 = new RangeSet(6); rs.removeAll(rs2); } @Test(expected = UnsupportedOperationException.class) public void removeAll1() throws Exception { RangeSet rs = new RangeSet(5); SmallIntSet sis = new SmallIntSet(); rs.removeAll(sis); } @Test(expected = UnsupportedOperationException.class) public void removeAll2() throws Exception { RangeSet rs = new RangeSet(4); Set<Integer> hashSet = new HashSet<>(); rs.removeAll(hashSet); }
### Question: RangeSet implements IntSet { @Override public boolean retainAll(Collection<?> c) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void retainAll() throws Exception { RangeSet rs = new RangeSet(4); RangeSet rs2 = new RangeSet(5); rs.retainAll(rs2); } @Test(expected = UnsupportedOperationException.class) public void retainAll1() throws Exception { IntSet rs = new RangeSet(5); SmallIntSet sis = new SmallIntSet(); rs.retainAll(sis); } @Test(expected = UnsupportedOperationException.class) public void retainAll2() throws Exception { RangeSet rs = new RangeSet(4); Set<Integer> hashSet = new HashSet<>(); rs.retainAll(hashSet); }
### Question: EmptyIntSet extends AbstractImmutableIntSet { @Override public boolean isEmpty() { return true; } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testIsEmpty() { assertTrue(es.isEmpty()); }
### Question: RangeSet implements IntSet { @Override public void clear() { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void clear() throws Exception { RangeSet rs = new RangeSet(5); rs.clear(); }
### Question: RangeSet implements IntSet { @Override public IntStream intStream() { return IntStream.range(0, size); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void intStream() throws Exception { IntSet rs = new RangeSet(5); assertEquals(10, rs.intStream().sum()); }
### Question: RangeSet implements IntSet { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null \|\| !(o instanceof Set)) return false; if (o instanceof RangeSet) { RangeSet integers = (RangeSet) o; return size == integers.size; } else { Set set = (Set) o; return size == set.size() && containsAll(set); } } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void equals() throws Exception { RangeSet rs = new RangeSet(4); RangeSet rs2 = new RangeSet(5); assertNotEquals(rs, rs2); assertNotEquals(rs2, rs); RangeSet rs3 = new RangeSet(4); assertEquals(rs3, rs); assertEquals(rs, rs3); }
### Question: RangeSet implements IntSet { @Override public boolean removeIf(IntPredicate filter) { throw new UnsupportedOperationException("RangeSet is immutable"); } RangeSet(int size); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean contains(int i); @Override PrimitiveIterator.OfInt iterator(); @Override int[] toIntArray(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Integer integer); @Override boolean remove(Object o); @Override boolean remove(int i); @Override boolean containsAll(Collection<?> c); @Override boolean containsAll(IntSet set); @Override boolean add(int i); void set(int i); @Override boolean addAll(IntSet set); @Override boolean addAll(Collection<? extends Integer> c); @Override boolean retainAll(Collection<?> c); @Override boolean retainAll(IntSet c); @Override boolean removeAll(IntSet set); @Override boolean removeAll(Collection<?> c); @Override void clear(); @Override boolean equals(Object o); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override boolean removeIf(IntPredicate filter); @Override int hashCode(); @Override String toString(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void removeIfPrimitive() { RangeSet rs = new RangeSet(4); rs.removeIf((int i) -> i == 3); } @Test(expected = UnsupportedOperationException.class) public void removeIfObject() { RangeSet rs = new RangeSet(4); rs.removeIf((Integer i) -> i == 3); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public int size() { return 1; } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testSize() { IntSet rs = new SingletonIntSet(3); assertEquals(1, rs.size()); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public boolean isEmpty() { return false; } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testIsEmpty() { IntSet rs = new SingletonIntSet(3); assertFalse(rs.isEmpty()); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public boolean contains(int i) { return value == i; } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testContains() throws Exception { IntSet sis = new SingletonIntSet(3); assertFalse(sis.contains(5)); assertTrue(sis.contains(3)); } @Test public void testContains1() throws Exception { IntSet sis = new SingletonIntSet(3); assertFalse(sis.contains(Integer.valueOf(5))); assertTrue(sis.contains(Integer.valueOf(3))); }
### Question: EmptyIntSet extends AbstractImmutableIntSet { @Override public boolean contains(int i) { return false; } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testContains() throws Exception { assertFalse(es.contains(5)); assertFalse(es.contains(3)); } @Test public void testContains1() throws Exception { assertFalse(es.contains(Integer.valueOf(5))); assertFalse(es.contains(Integer.valueOf(3))); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public PrimitiveIterator.OfInt iterator() { return new SingleIntIterator(); } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testIterator() throws Exception { IntSet sis = new SingletonIntSet(3); PrimitiveIterator.OfInt iterator = sis.iterator(); assertEquals(3, iterator.nextInt()); assertFalse(iterator.hasNext()); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public Object[] toArray() { Object[] array = new Object[1]; array[0] = value; return array; } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testToArray() throws Exception { IntSet sis = new SingletonIntSet(3); Object[] array = sis.toArray(); assertEquals(1, array.length); assertEquals(3, array[0]); } @Test public void testToArray1() throws Exception { IntSet sis = new SingletonIntSet(3); Object[] array = sis.toArray(new Integer[1]); assertEquals(1, array.length); assertEquals(3, array[0]); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public int[] toIntArray() { int[] array = new int[1]; array[0] = value; return array; } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testToIntArray() throws Exception { IntSet sis = new SingletonIntSet(3); int[] array = sis.toIntArray(); assertArrayEquals(new int[]{3}, array); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public boolean containsAll(IntSet set) { int size = set.size(); return size == 0 \|\| size == 1 && set.contains(value); } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testContainsAll() throws Exception { IntSet sis = new SingletonIntSet(3); IntSet sis2 = new SingletonIntSet(3); assertTrue(sis.containsAll(sis2)); assertTrue(sis2.containsAll(sis)); IntSet sis3 = new RangeSet(4); assertTrue(sis3.containsAll(sis)); assertFalse(sis.containsAll(sis3)); } @Test public void testContainsAll1() throws Exception { IntSet sis = new SingletonIntSet(3); Set<Integer> hashSet = new HashSet<>(Arrays.asList(3)); assertTrue(sis.containsAll(hashSet)); assertTrue(hashSet.containsAll(sis)); hashSet.add(0); assertTrue(hashSet.containsAll(sis)); assertFalse(sis.containsAll(hashSet)); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public IntStream intStream() { return IntStream.of(value); } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testIntStream() throws Exception { IntSet sis = new SingletonIntSet(3); assertEquals(1, sis.intStream().count()); }
### Question: SingletonIntSet extends AbstractImmutableIntSet { @Override public boolean equals(Object o) { if (o == this) { return true; } if (o == null \|\| !(o instanceof Set)) return false; if (o instanceof IntSet) { IntSet intSet = (IntSet) o; return intSet.size() == 1 && intSet.contains(value); } else { Set set = (Set) o; return set.size() == 1 && set.contains(value); } } SingletonIntSet(int value); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override int[] toIntArray(); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override void forEach(IntConsumer action); @Override void forEach(Consumer<? super Integer> action); @Override Spliterator.OfInt intSpliterator(); @Override Spliterator<Integer> spliterator(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); }### Answer: @Test public void testEquals() throws Exception { IntSet sis = new SingletonIntSet(3); IntSet sis2 = new SingletonIntSet(4); assertNotEquals(sis, sis2); assertNotEquals(sis2, sis); IntSet sis3 = SmallIntSet.of(3); assertEquals(sis3, sis); assertEquals(sis, sis3); }
### Question: ProcessorInfo { public static int availableProcessors() { if (System.getSecurityManager() != null) { return AccessController.doPrivileged((PrivilegedAction<Integer>) () -> Integer.valueOf(org.infinispan.commons.jdkspecific.ProcessorInfo.availableProcessors()).intValue()); } return org.infinispan.commons.jdkspecific.ProcessorInfo.availableProcessors(); } private ProcessorInfo(); static int availableProcessors(); static void main(String args[]); }### Answer: @Test @Category(Java11.class) public void testCPUCount() { assertTrue(ProcessorInfo.availableProcessors() <= Runtime.getRuntime().availableProcessors()); }
### Question: Features { public Features(ClassLoader classLoader) { features = new Properties(); try { Collection<URL> featureFiles = FileLookupFactory.newInstance().lookupFileLocations(FEATURES_FILE, classLoader); for (URL url : featureFiles) { try (InputStream is = url.openStream()) { features.load(is); } } if (log.isDebugEnabled()) { features.forEach((key, value) -> log.debugf("Feature %s=%s", key, value)); } } catch (IOException e) { log.debugf(e, "Error while attempting to obtain `%s` resources from the classpath", FEATURES_FILE); throw new CacheConfigurationException(e); } } Features(ClassLoader classLoader); Features(); boolean isAvailable(String featureName); static final String FEATURE_PREFIX; }### Answer: @Test public void testFeatures() { Features features = new Features(); assertFalse(features.isAvailable("A")); assertTrue(features.isAvailable("B")); }
### Question: Features { public boolean isAvailable(String featureName) { String name = FEATURE_PREFIX + featureName; String sysprop = SecurityActions.getProperty(name); if (sysprop != null) { return Boolean.parseBoolean(sysprop); } else { return Boolean.parseBoolean(features.getProperty(name, "true")); } } Features(ClassLoader classLoader); Features(); boolean isAvailable(String featureName); static final String FEATURE_PREFIX; }### Answer: @Test public void featureSysOverride() { Features features = new Features(); assertFalse(features.isAvailable("A")); System.setProperty("org.infinispan.feature.A", "true"); System.setProperty("org.infinispan.feature.B", "false"); boolean a = features.isAvailable("A"); boolean b = features.isAvailable("B"); System.clearProperty("org.infinispan.feature.A"); System.clearProperty("org.infinispan.feature.B"); assertTrue(a); assertFalse(b); }
### Question: JavaSerializationMarshaller extends AbstractMarshaller { @Override public Object objectFromByteBuffer(byte[] buf, int offset, int length) throws IOException, ClassNotFoundException { try (ObjectInputStream ois = new CheckedInputStream(new ByteArrayInputStream(buf), allowList)) { return ois.readObject(); } } JavaSerializationMarshaller(); JavaSerializationMarshaller(ClassAllowList allowList); @Override void initialize(ClassAllowList classAllowList); @Override Object objectFromByteBuffer(byte[] buf, int offset, int length); @Override boolean isMarshallable(Object o); @Override MediaType mediaType(); }### Answer: @Test public void testPrimitiveArrays() throws Exception { JavaSerializationMarshaller marshaller = new JavaSerializationMarshaller(); byte[] bytes = marshaller.objectToByteBuffer(new byte[0]); assertArrayEquals(new byte[0], (byte[]) marshaller.objectFromByteBuffer(bytes)); bytes = marshaller.objectToByteBuffer(new short[0]); assertArrayEquals(new short[0], (short[]) marshaller.objectFromByteBuffer(bytes)); bytes = marshaller.objectToByteBuffer(new int[0]); assertArrayEquals(new int[0], (int[]) marshaller.objectFromByteBuffer(bytes)); bytes = marshaller.objectToByteBuffer(new long[0]); assertArrayEquals(new long[0], (long[]) marshaller.objectFromByteBuffer(bytes)); bytes = marshaller.objectToByteBuffer(new float[0]); assertArrayEquals(new float[0], (float[]) marshaller.objectFromByteBuffer(bytes), 0); bytes = marshaller.objectToByteBuffer(new double[0]); assertArrayEquals(new double[0], (double[]) marshaller.objectFromByteBuffer(bytes), 0); bytes = marshaller.objectToByteBuffer(new char[0]); assertArrayEquals(new char[0], (char[]) marshaller.objectFromByteBuffer(bytes)); bytes = marshaller.objectToByteBuffer(new boolean[0]); assertArrayEquals(new boolean[0], (boolean[]) marshaller.objectFromByteBuffer(bytes)); }
### Question: JavaSerializationMarshaller extends AbstractMarshaller { @Override public boolean isMarshallable(Object o) { return o instanceof Serializable; } JavaSerializationMarshaller(); JavaSerializationMarshaller(ClassAllowList allowList); @Override void initialize(ClassAllowList classAllowList); @Override Object objectFromByteBuffer(byte[] buf, int offset, int length); @Override boolean isMarshallable(Object o); @Override MediaType mediaType(); }### Answer: @Test public void testBoxedPrimitivesAndArray() throws Exception { JavaSerializationMarshaller marshaller = new JavaSerializationMarshaller(); isMarshallable(marshaller, Byte.MAX_VALUE); isMarshallable(marshaller, Short.MAX_VALUE); isMarshallable(marshaller, Integer.MAX_VALUE); isMarshallable(marshaller, Long.MAX_VALUE); isMarshallable(marshaller, Float.MAX_VALUE); isMarshallable(marshaller, Double.MAX_VALUE); isMarshallable(marshaller, 'c'); isMarshallable(marshaller, "String"); } @Test public void testMath() throws Exception { JavaSerializationMarshaller marshaller = new JavaSerializationMarshaller(); isMarshallable(marshaller, BigDecimal.TEN); isMarshallable(marshaller, BigInteger.TEN); } @Test public void testDate() throws Exception { JavaSerializationMarshaller marshaller = new JavaSerializationMarshaller(); isMarshallable(marshaller, Instant.now()); }
### Question: MediaTypeResolver { public static String getMediaType(String fileName) { if (fileName == null) return null; int idx = fileName.lastIndexOf("."); if (idx == -1 \|\| idx == fileName.length()) return null; return FILE_MAP.get(fileName.toLowerCase().substring(idx + 1)); } private MediaTypeResolver(); static String getMediaType(String fileName); }### Answer: @Test public void testResolver() { assertNull(MediaTypeResolver.getMediaType(null)); assertNull(MediaTypeResolver.getMediaType("noextension")); assertNull(MediaTypeResolver.getMediaType("124.")); assertEquals("application/javascript", MediaTypeResolver.getMediaType("file.js")); assertEquals("image/jpeg", MediaTypeResolver.getMediaType("file.jpg")); assertEquals("image/jpeg", MediaTypeResolver.getMediaType("file.jpeg")); assertEquals("image/jpeg", MediaTypeResolver.getMediaType("file.jpe")); assertEquals("text/css", MediaTypeResolver.getMediaType("file.css")); assertEquals("text/html", MediaTypeResolver.getMediaType("file.htm")); assertEquals("text/html", MediaTypeResolver.getMediaType("file.html")); assertEquals("application/java-archive", MediaTypeResolver.getMediaType("file.JAR")); }
### Question: EmptyIntSet extends AbstractImmutableIntSet { @Override public PrimitiveIterator.OfInt iterator() { return EmptyIntIterator.INSTANCE; } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testIterator() throws Exception { PrimitiveIterator.OfInt iterator = es.iterator(); assertFalse(iterator.hasNext()); }
### Question: EmptyIntSet extends AbstractImmutableIntSet { @Override public Object[] toArray() { return new Object[0]; } static IntSet getInstance(); @Override boolean contains(int i); @Override boolean containsAll(IntSet set); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override PrimitiveIterator.OfInt iterator(); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean containsAll(Collection<?> c); @Override IntStream intStream(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testToArray() throws Exception { Object[] array = es.toArray(); assertEquals(0, array.length); } @Test public void testToArray1() throws Exception { Object[] array = es.toArray(new Integer[1]); assertEquals(1, array.length); assertEquals(null, array[0]); array = es.toArray(new Integer[0]); assertEquals(0, array.length); }

Subsets and Splits

No saved queries yet

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