method2testcases stringlengths 118 3.08k |
|---|
### Question:
PrepareBlockchain { public boolean verifyContractFile(File contractFile, ContractVersion contractVersion) { try (InputStream is = new FileInputStream(contractFile)) { byte[] contractBinary = IOUtils.toByteArray(is); ContractVersion checkVersion = ContractVersion.of(contractBinary); return contractVersion.toString().equals(checkVersion.toString()); } catch (IOException e) { log.warn(e.getMessage()); } return false; } PrepareBlockchain(String contractPath); File loadContractFile(ContractVersion version); boolean verifyContractFile(File contractFile, ContractVersion contractVersion); }### Answer:
@Test public void verifyContractFile() { PrepareBlockchain pb = new PrepareBlockchain(new DefaultConfig().getContractPath()); URL contractFile = getClass().getClassLoader() .getResource("contracts/74df17611373672371cb3872e8a5d4a2e8733fb1.jar"); String file = contractFile.getFile(); log.debug(file); File f = new File(file); ContractVersion version = ContractVersion.of("74df17611373672371cb3872e8a5d4a2e8733fb1"); boolean verify = pb.verifyContractFile(f, version); assert verify == true; } |
### Question:
Address { @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } Address address = (Address) o; return Arrays.equals(data, address.data); } Address(byte[] data); private Address(byte[] data, boolean hashed); byte[] getBytes(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static Address of(String addr); static final Address NULL_ADDRESS; }### Answer:
@Test public void equalsTest() { assertThat(Address.of("c91e9d46dd4b7584f0b6348ee18277c10fd7cb94")).isEqualTo(Address.of(ADDRESS_HEX)); assertThat(Address.of("00")).isNotEqualTo(Address.of(ADDRESS_HEX)); } |
### Question:
Address { @Override public String toString() { return Hex.toHexString(data); } Address(byte[] data); private Address(byte[] data, boolean hashed); byte[] getBytes(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static Address of(String addr); static final Address NULL_ADDRESS; }### Answer:
@Test public void toStringTest() { assertThat(Address.of(ADDRESS_HEX).toString()).isEqualTo(ADDRESS_HEX); } |
### Question:
Address { @Override public int hashCode() { return Arrays.hashCode(data); } Address(byte[] data); private Address(byte[] data, boolean hashed); byte[] getBytes(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static Address of(String addr); static final Address NULL_ADDRESS; }### Answer:
@Test public void hashCodeTest() { assertThat(Address.of(ADDRESS_HEX).hashCode()).isEqualTo(Arrays.hashCode(ADDRESS_BYTES)); } |
### Question:
TransactionApiImpl implements TransactionApi { @Override public int getTransactionCountByBlockNumber(String branchId, long blockNumber) { ConsensusBlock block = branchGroup.getBlockByIndex(BranchId.of(branchId), blockNumber); return block.getBody().getCount(); } @Autowired TransactionApiImpl(BranchGroup branchGroup); @Override int getTransactionCountByBlockHash(String branchId, String blockId); @Override int getTransactionCountByBlockNumber(String branchId, long blockNumber); @Override TransactionDto getTransactionByHash(String branchId, String txId); @Override TransactionDto getTransactionByBlockHash(String branchId, String blockId,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, String tag,
int txIndexPosition); @Override TransactionResponseDto sendTransaction(TransactionDto tx); @Override TransactionResponseDto sendRawTransaction(byte[] bytes); @Override int newPendingTransactionFilter(String branchId); @Override List<String> getPendingTransactionList(String branchId); @Override int getPendingTransactionCount(String branchId); @Override TransactionReceiptDto getTransactionReceipt(String branchId, String txId); @Override String getRawTransaction(String branchId, String txId); @Override String getRawTransactionHeader(String branchId, String txId); }### Answer:
@Test public void getBlockTransactionCountByNumberTest() { assertThat(txApi.getTransactionCountByBlockNumber(yggdrashBranch, 0)) .isNotZero(); } |
### Question:
TransactionApiImpl implements TransactionApi { @Override public TransactionDto getTransactionByHash(String branchId, String txId) { Transaction tx = branchGroup.getTxByHash(BranchId.of(branchId), txId); return TransactionDto.createBy(tx); } @Autowired TransactionApiImpl(BranchGroup branchGroup); @Override int getTransactionCountByBlockHash(String branchId, String blockId); @Override int getTransactionCountByBlockNumber(String branchId, long blockNumber); @Override TransactionDto getTransactionByHash(String branchId, String txId); @Override TransactionDto getTransactionByBlockHash(String branchId, String blockId,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, String tag,
int txIndexPosition); @Override TransactionResponseDto sendTransaction(TransactionDto tx); @Override TransactionResponseDto sendRawTransaction(byte[] bytes); @Override int newPendingTransactionFilter(String branchId); @Override List<String> getPendingTransactionList(String branchId); @Override int getPendingTransactionCount(String branchId); @Override TransactionReceiptDto getTransactionReceipt(String branchId, String txId); @Override String getRawTransaction(String branchId, String txId); @Override String getRawTransactionHeader(String branchId, String txId); }### Answer:
@Test public void getTransactionByHashTest() { assertThat(txApi.getTransactionByHash(yggdrashBranch, testTransactionHash)) .isNotNull(); } |
### Question:
TransactionApiImpl implements TransactionApi { @Override public TransactionDto getTransactionByBlockHash(String branchId, String blockId, int txIndexPosition) { ConsensusBlock block = branchGroup.getBlockByHash(BranchId.of(branchId), blockId); List<Transaction> txList = block.getBody().getTransactionList(); return TransactionDto.createBy(txList.get(txIndexPosition)); } @Autowired TransactionApiImpl(BranchGroup branchGroup); @Override int getTransactionCountByBlockHash(String branchId, String blockId); @Override int getTransactionCountByBlockNumber(String branchId, long blockNumber); @Override TransactionDto getTransactionByHash(String branchId, String txId); @Override TransactionDto getTransactionByBlockHash(String branchId, String blockId,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, String tag,
int txIndexPosition); @Override TransactionResponseDto sendTransaction(TransactionDto tx); @Override TransactionResponseDto sendRawTransaction(byte[] bytes); @Override int newPendingTransactionFilter(String branchId); @Override List<String> getPendingTransactionList(String branchId); @Override int getPendingTransactionCount(String branchId); @Override TransactionReceiptDto getTransactionReceipt(String branchId, String txId); @Override String getRawTransaction(String branchId, String txId); @Override String getRawTransactionHeader(String branchId, String txId); }### Answer:
@Test public void getTransactionByBlockHashTest() { assertThat(txApi.getTransactionByBlockHash(yggdrashBranch, testBlockHash, 0)).isNotNull(); } |
### Question:
TransactionApiImpl implements TransactionApi { @Override public TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber, int txIndexPosition) { ConsensusBlock block = branchGroup.getBlockByIndex(BranchId.of(branchId), blockNumber); List<Transaction> txList = block.getBody().getTransactionList(); return TransactionDto.createBy(txList.get(txIndexPosition)); } @Autowired TransactionApiImpl(BranchGroup branchGroup); @Override int getTransactionCountByBlockHash(String branchId, String blockId); @Override int getTransactionCountByBlockNumber(String branchId, long blockNumber); @Override TransactionDto getTransactionByHash(String branchId, String txId); @Override TransactionDto getTransactionByBlockHash(String branchId, String blockId,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, String tag,
int txIndexPosition); @Override TransactionResponseDto sendTransaction(TransactionDto tx); @Override TransactionResponseDto sendRawTransaction(byte[] bytes); @Override int newPendingTransactionFilter(String branchId); @Override List<String> getPendingTransactionList(String branchId); @Override int getPendingTransactionCount(String branchId); @Override TransactionReceiptDto getTransactionReceipt(String branchId, String txId); @Override String getRawTransaction(String branchId, String txId); @Override String getRawTransactionHeader(String branchId, String txId); }### Answer:
@Test public void getTransactionByBlockNumberTest() { assertThat(txApi.getTransactionByBlockNumber(yggdrashBranch, 0, 0)) .isNotNull(); }
@Test public void getTransactionByBlockNumberWithTagTest() { try { String tag = "latest"; Assert.assertNotNull(txApi.getTransactionByBlockNumber(yggdrashBranch, tag, 0)); } catch (Exception e) { log.debug("\n\ngetTransactionByBlockNumberWithTagTest :: exception => " + e); } } |
### Question:
NodeApiImpl implements NodeApi { @Override public NodeStatusDto getNodeStatus() { return NodeStatusDto.createBy(branchGroup, peerTableGroup); } @Autowired NodeApiImpl(BranchGroup branchGroup, PeerTableGroup peerTableGroup); @Override NodeStatusDto getNodeStatus(); }### Answer:
@Test public void getNodeStatusTest() { NodeStatusDto res = nodeApi.getNodeStatus(); assertNotNull(res); printResult(res); }
@Test public void getNodeStatusJsonRpcTest() { try { printResult(NODE_API.getNodeStatus()); } catch (Exception e) { log.debug("getNodeStatusTest :: ERR => {}", e.getMessage()); } } |
### Question:
TransactionApiImpl implements TransactionApi { @Override public TransactionResponseDto sendRawTransaction(byte[] bytes) { Transaction transaction = TransactionImpl.parseFromRaw(bytes); return addTx(transaction); } @Autowired TransactionApiImpl(BranchGroup branchGroup); @Override int getTransactionCountByBlockHash(String branchId, String blockId); @Override int getTransactionCountByBlockNumber(String branchId, long blockNumber); @Override TransactionDto getTransactionByHash(String branchId, String txId); @Override TransactionDto getTransactionByBlockHash(String branchId, String blockId,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, String tag,
int txIndexPosition); @Override TransactionResponseDto sendTransaction(TransactionDto tx); @Override TransactionResponseDto sendRawTransaction(byte[] bytes); @Override int newPendingTransactionFilter(String branchId); @Override List<String> getPendingTransactionList(String branchId); @Override int getPendingTransactionCount(String branchId); @Override TransactionReceiptDto getTransactionReceipt(String branchId, String txId); @Override String getRawTransaction(String branchId, String txId); @Override String getRawTransactionHeader(String branchId, String txId); }### Answer:
@Test @Ignore public void sendRawTransactionTest() { try { byte[] input = createTx().toRawTransaction(); TransactionResponseDto res = TX_API.sendRawTransaction(input); assertTrue(res.status); } catch (Exception e) { log.debug("\n\ninvalidTransactionTest :: ERR => {}", e.getMessage()); e.printStackTrace(); } }
@Test public void sendInvalidDataFormatOfRawTx() { byte[] input = "Invalid Raw Transaction Input Data".getBytes(); TransactionResponseDto transactionResponseDto = txApi.sendRawTransaction(input); assertTrue(!transactionResponseDto.logs.isEmpty()); } |
### Question:
TransactionApiImpl implements TransactionApi { @Override public int newPendingTransactionFilter(String branchId) { return branchGroup.getUnconfirmedTxs(BranchId.of(branchId)).size(); } @Autowired TransactionApiImpl(BranchGroup branchGroup); @Override int getTransactionCountByBlockHash(String branchId, String blockId); @Override int getTransactionCountByBlockNumber(String branchId, long blockNumber); @Override TransactionDto getTransactionByHash(String branchId, String txId); @Override TransactionDto getTransactionByBlockHash(String branchId, String blockId,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, String tag,
int txIndexPosition); @Override TransactionResponseDto sendTransaction(TransactionDto tx); @Override TransactionResponseDto sendRawTransaction(byte[] bytes); @Override int newPendingTransactionFilter(String branchId); @Override List<String> getPendingTransactionList(String branchId); @Override int getPendingTransactionCount(String branchId); @Override TransactionReceiptDto getTransactionReceipt(String branchId, String txId); @Override String getRawTransaction(String branchId, String txId); @Override String getRawTransactionHeader(String branchId, String txId); }### Answer:
@Test @Ignore public void newPendingTransactionFilterTest() { try { assertThat(TX_API.newPendingTransactionFilter(yggdrashBranch)) .isGreaterThanOrEqualTo(0); } catch (Exception e) { log.debug("\n\nnewPendingTransactionFilterTest :: exception => " + e); } } |
### Question:
TransactionApiImpl implements TransactionApi { @Override public List<String> getPendingTransactionList(String branchId) { return branchGroup.getUnconfirmedTxs(BranchId.of(branchId)) .stream().map(tx -> tx.getHash().toString()).collect(Collectors.toList()); } @Autowired TransactionApiImpl(BranchGroup branchGroup); @Override int getTransactionCountByBlockHash(String branchId, String blockId); @Override int getTransactionCountByBlockNumber(String branchId, long blockNumber); @Override TransactionDto getTransactionByHash(String branchId, String txId); @Override TransactionDto getTransactionByBlockHash(String branchId, String blockId,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, String tag,
int txIndexPosition); @Override TransactionResponseDto sendTransaction(TransactionDto tx); @Override TransactionResponseDto sendRawTransaction(byte[] bytes); @Override int newPendingTransactionFilter(String branchId); @Override List<String> getPendingTransactionList(String branchId); @Override int getPendingTransactionCount(String branchId); @Override TransactionReceiptDto getTransactionReceipt(String branchId, String txId); @Override String getRawTransaction(String branchId, String txId); @Override String getRawTransactionHeader(String branchId, String txId); }### Answer:
@Test public void getPendingTransactionListTest() { assertThat(txApi.getPendingTransactionList(yggdrashBranch)).isNotNull(); } |
### Question:
TransactionApiImpl implements TransactionApi { @Override public int getPendingTransactionCount(String branchId) { return branchGroup.getUnconfirmedTxs((BranchId.of(branchId))).size(); } @Autowired TransactionApiImpl(BranchGroup branchGroup); @Override int getTransactionCountByBlockHash(String branchId, String blockId); @Override int getTransactionCountByBlockNumber(String branchId, long blockNumber); @Override TransactionDto getTransactionByHash(String branchId, String txId); @Override TransactionDto getTransactionByBlockHash(String branchId, String blockId,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, String tag,
int txIndexPosition); @Override TransactionResponseDto sendTransaction(TransactionDto tx); @Override TransactionResponseDto sendRawTransaction(byte[] bytes); @Override int newPendingTransactionFilter(String branchId); @Override List<String> getPendingTransactionList(String branchId); @Override int getPendingTransactionCount(String branchId); @Override TransactionReceiptDto getTransactionReceipt(String branchId, String txId); @Override String getRawTransaction(String branchId, String txId); @Override String getRawTransactionHeader(String branchId, String txId); }### Answer:
@Test public void getPendingTransactionCountTest() { assertTrue(txApi.getPendingTransactionCount(yggdrashBranch) > -1); } |
### Question:
TransactionApiImpl implements TransactionApi { @Override public TransactionReceiptDto getTransactionReceipt(String branchId, String txId) { return TransactionReceiptDto.createBy(branchGroup.getReceipt(BranchId.of(branchId), txId)); } @Autowired TransactionApiImpl(BranchGroup branchGroup); @Override int getTransactionCountByBlockHash(String branchId, String blockId); @Override int getTransactionCountByBlockNumber(String branchId, long blockNumber); @Override TransactionDto getTransactionByHash(String branchId, String txId); @Override TransactionDto getTransactionByBlockHash(String branchId, String blockId,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, String tag,
int txIndexPosition); @Override TransactionResponseDto sendTransaction(TransactionDto tx); @Override TransactionResponseDto sendRawTransaction(byte[] bytes); @Override int newPendingTransactionFilter(String branchId); @Override List<String> getPendingTransactionList(String branchId); @Override int getPendingTransactionCount(String branchId); @Override TransactionReceiptDto getTransactionReceipt(String branchId, String txId); @Override String getRawTransaction(String branchId, String txId); @Override String getRawTransactionHeader(String branchId, String txId); }### Answer:
@Test public void getTransactionReceiptTest() { assertThat(txApi.getTransactionReceipt(yggdrashBranch, testTransactionHash)) .isNotNull(); }
@Test public void getNullTransactionReceiptTest() { String invalidTxHash = "bce7bce793985a1cde7791acbbeb16037d7b86b967df4213329b2e3cc45995fe"; assertThat(txApi.getTransactionReceipt(yggdrashBranch, invalidTxHash).txId) .isNull(); } |
### Question:
TransactionApiImpl implements TransactionApi { @Override public String getRawTransaction(String branchId, String txId) { Transaction tx = branchGroup.getTxByHash(BranchId.of(branchId), txId); byte[] rawTransaction = tx.toRawTransaction(); return HexUtil.toHexString(rawTransaction); } @Autowired TransactionApiImpl(BranchGroup branchGroup); @Override int getTransactionCountByBlockHash(String branchId, String blockId); @Override int getTransactionCountByBlockNumber(String branchId, long blockNumber); @Override TransactionDto getTransactionByHash(String branchId, String txId); @Override TransactionDto getTransactionByBlockHash(String branchId, String blockId,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, String tag,
int txIndexPosition); @Override TransactionResponseDto sendTransaction(TransactionDto tx); @Override TransactionResponseDto sendRawTransaction(byte[] bytes); @Override int newPendingTransactionFilter(String branchId); @Override List<String> getPendingTransactionList(String branchId); @Override int getPendingTransactionCount(String branchId); @Override TransactionReceiptDto getTransactionReceipt(String branchId, String txId); @Override String getRawTransaction(String branchId, String txId); @Override String getRawTransactionHeader(String branchId, String txId); }### Answer:
@Test public void getRawTransactionTest() { assertThat(txApi.getRawTransaction(yggdrashBranch, testTransactionHash)) .isNotNull(); } |
### Question:
TransactionApiImpl implements TransactionApi { @Override public String getRawTransactionHeader(String branchId, String txId) { Transaction tx = branchGroup.getTxByHash(BranchId.of(branchId), txId); byte[] rawTransactionBinary = tx.getHeader().getBinaryForSigning(); byte[] transactionSign = tx.getSignature(); ByteArrayOutputStream bao = new ByteArrayOutputStream(); try { bao.write(rawTransactionBinary); bao.write(transactionSign); } catch (IOException e) { throw new WrongStructuredException.InvalidTx(); } byte[] rawTransactionHeader = bao.toByteArray(); return HexUtil.toHexString(rawTransactionHeader); } @Autowired TransactionApiImpl(BranchGroup branchGroup); @Override int getTransactionCountByBlockHash(String branchId, String blockId); @Override int getTransactionCountByBlockNumber(String branchId, long blockNumber); @Override TransactionDto getTransactionByHash(String branchId, String txId); @Override TransactionDto getTransactionByBlockHash(String branchId, String blockId,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, long blockNumber,
int txIndexPosition); @Override TransactionDto getTransactionByBlockNumber(String branchId, String tag,
int txIndexPosition); @Override TransactionResponseDto sendTransaction(TransactionDto tx); @Override TransactionResponseDto sendRawTransaction(byte[] bytes); @Override int newPendingTransactionFilter(String branchId); @Override List<String> getPendingTransactionList(String branchId); @Override int getPendingTransactionCount(String branchId); @Override TransactionReceiptDto getTransactionReceipt(String branchId, String txId); @Override String getRawTransaction(String branchId, String txId); @Override String getRawTransactionHeader(String branchId, String txId); }### Answer:
@Test public void getRawTransactionHeaderTest() { assertThat(txApi.getRawTransactionHeader(yggdrashBranch, testTransactionHash)) .isNotNull(); } |
### Question:
BranchConfiguration { @Bean BranchLoader branchLoader(DefaultConfig defaultConfig, BranchGroup branchGroup, Environment env, NodeStatus nodeStatus) { BranchLoader branchLoader = new BranchLoader(defaultConfig.getBranchPath()); boolean isValidator = Arrays.asList(env.getActiveProfiles()).contains(ActiveProfiles.VALIDATOR); boolean isBsNode = Arrays.asList(env.getActiveProfiles()).contains(ActiveProfiles.BOOTSTRAP); if (isValidator || isBsNode) { return branchLoader; } try { for (GenesisBlock genesis : branchLoader.getGenesisBlockList()) { if (branchGroup.isBranchExist(genesis.getBranchId())) { continue; } BlockChain bc = createBranch(genesis); branchGroup.addBranch(bc); bc.getContractManager().setNodeStatus(nodeStatus); } } catch (Exception e) { log.warn("branchLoader() is failed.", e.getMessage()); } return branchLoader; } @Autowired BranchConfiguration(DefaultConfig defaultConfig); }### Answer:
@Test public void branchLoaderTest() throws IOException { JsonObject branchJson = getBranchJson(); Branch branch = getBranchByJsonObj(branchJson); BranchId branchId = branch.getBranchId(); log.debug("branchId : {}", branchId); saveFile(branchId, branchJson); BranchGroup branchGroup = branchConfig.branchGroup(); branchConfig.branchLoader(config, branchGroup, new MockEnvironment(), nodeStatus); File branchDir = new File(config.getBranchPath(), branchId.toString()); FileUtils.deleteQuietly(branchDir); BlockChain blockChain = branchGroup.getBranch(branchId); assertNotNull(blockChain); assertEquals(blockChain.getBranchId(), branchId); assertTransaction(blockChain); } |
### Question:
PeerTask { @Scheduled(cron = "*/" + KademliaOptions.BUCKET_REFRESH + " * * * * *") public void refresh() { try { peerTableGroup.refresh(); log.debug("refresh(): {}", peerTableGroup.getActivePeerListWithStatus()); } catch (Exception e) { log.warn("refresh() is failed. {}", e.getMessage()); } } @Autowired void setPeerTableGroup(PeerTableGroup peerTableGroup); @Autowired void setPeerDialer(PeerDialer peerDialer); @Autowired void setListener(CatchUpSyncEventListener listener); @Autowired void setPeerNetwork(PeerNetwork peerNetwork); @Scheduled(initialDelay = NODE_DISCOVERY_INITDELAY, fixedRate = NODE_DISCOVERY_TIME) void healthCheck(); @Scheduled(cron = "*/" + KademliaOptions.BUCKET_REFRESH + " * * * * *") void refresh(); }### Answer:
@Test public void refreshTest() { assertEquals(0, peerTableGroup.getPeerTable(yggdrash).getBucketsCount()); peerTask.refresh(); assertEquals(4, peerTableGroup.getPeerTable(yggdrash).getBucketsCount()); } |
### Question:
IpBlockInterceptor implements ServerInterceptor { public void setBlackIps(String[] ips) { this.blackIps = ips; this.blackIpsForLog = Arrays.toString(blackIps); } void setBlackIps(String[] ips); @Override ServerCall.Listener<ReqT> interceptCall(
ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next); }### Answer:
@Test(expected = StatusRuntimeException.class) public void testIpBlockInterceptor() { assertThat(grpcServerRunner).isNotNull(); ManagedChannel channel = ManagedChannelBuilder .forAddress("localhost", runningPort) .usePlaintext().build(); Proto.Pong reply = DiscoveryServiceGrpc.newBlockingStub(channel) .ping(Proto.Ping.newBuilder().setPing("Ping").build()); reply.getPong(); assertThat(reply.getPong()).isEqualTo("Pong"); ((IpBlockInterceptor) ipBlockInterceptor).setBlackIps(new String[] {"127.0.0.1"}); DiscoveryServiceGrpc.newBlockingStub(channel).ping(Proto.Ping.newBuilder().setPing("Ping").build()); } |
### Question:
NodeHealthIndicator implements HealthIndicator, NodeStatus { @Override public Health health() { updateDetail(health.get().getStatus()); return health.get(); } @Autowired NodeHealthIndicator(DefaultConfig defaultConfig, BranchGroup branchGroup,
PeerDialer peerDialer); @Override Health health(); @Override void up(); @Override void sync(); @Override void update(); @Override boolean isUpdateStatus(); @Override boolean isUpStatus(); @Override boolean isSyncStatus(); }### Answer:
@Test public void health() { Health health = nodeHealthIndicator.health(); assertEquals(Status.DOWN, health.getStatus()); assertEquals("yggdrash", health.getDetails().get("name")); assertNotNull(health.getDetails().get("branches")); assertEquals(0, (int) health.getDetails().get("activePeers")); } |
### Question:
NodeHealthIndicator implements HealthIndicator, NodeStatus { @Override public void up() { try { updateDetail(Status.UP); } catch (Exception e) { log.debug("Status up() is failed. {}", e.getMessage()); } finally { log.debug("nodeStatus -> {}", health.get().getStatus()); } } @Autowired NodeHealthIndicator(DefaultConfig defaultConfig, BranchGroup branchGroup,
PeerDialer peerDialer); @Override Health health(); @Override void up(); @Override void sync(); @Override void update(); @Override boolean isUpdateStatus(); @Override boolean isUpStatus(); @Override boolean isSyncStatus(); }### Answer:
@Test public void up() { assertEquals(Status.DOWN, nodeHealthIndicator.health().getStatus()); nodeHealthIndicator.up(); assertEquals(Status.UP, nodeHealthIndicator.health().getStatus()); } |
### Question:
NodeHealthIndicator implements HealthIndicator, NodeStatus { @Override public void sync() { try { updateDetail(SYNC); } catch (Exception e) { log.debug("Status sync() is failed. {}", e.getMessage()); } finally { log.debug("nodeStatus -> {}", health.get().getStatus()); } } @Autowired NodeHealthIndicator(DefaultConfig defaultConfig, BranchGroup branchGroup,
PeerDialer peerDialer); @Override Health health(); @Override void up(); @Override void sync(); @Override void update(); @Override boolean isUpdateStatus(); @Override boolean isUpStatus(); @Override boolean isSyncStatus(); }### Answer:
@Test public void sync() { assertEquals(Status.DOWN, nodeHealthIndicator.health().getStatus()); nodeHealthIndicator.sync(); assertEquals(SYNC.getCode(), nodeHealthIndicator.health().getStatus().getCode()); } |
### Question:
NodeHealthIndicator implements HealthIndicator, NodeStatus { @Override public void update() { try { updateDetail(UPDATE); } catch (Exception e) { log.debug("Status update() is failed. {}", e.getMessage()); } finally { log.debug("nodeStatus -> {}", health.get().getStatus()); } } @Autowired NodeHealthIndicator(DefaultConfig defaultConfig, BranchGroup branchGroup,
PeerDialer peerDialer); @Override Health health(); @Override void up(); @Override void sync(); @Override void update(); @Override boolean isUpdateStatus(); @Override boolean isUpStatus(); @Override boolean isSyncStatus(); }### Answer:
@Test public void update() { assertEquals(Status.DOWN, nodeHealthIndicator.health().getStatus()); nodeHealthIndicator.update(); assertEquals(UPDATE.getCode(), nodeHealthIndicator.health().getStatus().getCode()); } |
### Question:
EbftBlockChain implements ConsensusBlockChain<EbftProto.EbftBlock, EbftBlock> { @Override public Map<String, List<String>> addBlock(ConsensusBlock<EbftProto.EbftBlock> block) { this.lock.lock(); try { blockChainManagerMock.addBlock(block); this.blockKeyStore.put(block.getIndex(), block.getHash().getBytes()); loggingBlock((EbftBlock) block); } finally { this.lock.unlock(); } return new HashMap<>(); } EbftBlockChain(Block genesisBlock,
String dbPath,
String blockKeyStorePath,
String blockStorePath
); @Override BranchId getBranchId(); @Override Consensus getConsensus(); @Override EbftBlockKeyStore getBlockKeyStore(); @Override BlockChainManager<EbftProto.EbftBlock> getBlockChainManager(); @Override ContractManager getContractManager(); @Override EbftBlock getGenesisBlock(); @Override Map<String, EbftBlock> getUnConfirmedData(); @Override ReentrantLock getLock(); @Override Map<String, List<String>> addBlock(ConsensusBlock<EbftProto.EbftBlock> block); @Override Map<String, List<String>> addBlock(ConsensusBlock<EbftProto.EbftBlock> block, boolean broadcast); @Override boolean isValidator(String addr); @Override ValidatorSet getValidators(); }### Answer:
@Test public void addBlockTest() { this.ebftBlockChain.addBlock(ebftBlock1); assertEquals(1L, this.blockChainManager.getLastIndex()); this.ebftBlockChain.addBlock(ebftBlock2); assertEquals(2L, this.blockChainManager.getLastIndex()); this.ebftBlockChain.addBlock(ebftBlock3); assertEquals(3L, this.blockChainManager.getLastIndex()); } |
### Question:
EbftStatus { public List<EbftBlock> getUnConfirmedEbftBlockList() { return unConfirmedEbftBlockList; } EbftStatus(long index, List<EbftBlock> unConfirmedEbftBlockList, Wallet wallet); EbftStatus(EbftProto.EbftStatus nodeStatus); long getIndex(); List<EbftBlock> getUnConfirmedEbftBlockList(); long getTimestamp(); byte[] getSignature(); static boolean verify(EbftStatus ebftStatus); static EbftProto.EbftStatus toProto(EbftStatus ebftStatus); JsonObject toJsonObject(); @Override boolean equals(Object o); @Override int hashCode(); void clear(); }### Answer:
@Test public void constuctorTest_Default() { assertEquals(3, ebftStatus1.getUnConfirmedEbftBlockList().size()); assertEquals(3, ebftStatus2.getUnConfirmedEbftBlockList().size()); assertEquals(3, ebftStatus3.getUnConfirmedEbftBlockList().size()); } |
### Question:
BlockApiImpl implements BlockApi { @Override public long blockNumber(String branchId) { return branchGroup.getLastIndex(BranchId.of(branchId)); } @Autowired BlockApiImpl(BranchGroup branchGroup); @Override long blockNumber(String branchId); @Override BlockDto getBlockByHash(String branchId, String blockId, Boolean bool); @Override BlockDto getBlockByNumber(String branchId, long numOfBlock, Boolean bool); @Override BlockDto getLastBlock(String branchId); }### Answer:
@Test public void blockNumberTest() { try { assertThat(BLOCK_API.blockNumber(branchId)).isNotNull(); } catch (Exception exception) { log.debug("blockNumberTest :: exception : " + exception); } } |
### Question:
EbftStatus { public static boolean verify(EbftStatus ebftStatus) { if (ebftStatus != null) { return Wallet.verify( ebftStatus.getHashForSigning(), ebftStatus.getSignature(), true); } return false; } EbftStatus(long index, List<EbftBlock> unConfirmedEbftBlockList, Wallet wallet); EbftStatus(EbftProto.EbftStatus nodeStatus); long getIndex(); List<EbftBlock> getUnConfirmedEbftBlockList(); long getTimestamp(); byte[] getSignature(); static boolean verify(EbftStatus ebftStatus); static EbftProto.EbftStatus toProto(EbftStatus ebftStatus); JsonObject toJsonObject(); @Override boolean equals(Object o); @Override int hashCode(); void clear(); }### Answer:
@Test public void verifyTest() { assertTrue(EbftStatus.verify(this.ebftStatus1)); assertTrue(EbftStatus.verify(this.ebftStatus2)); assertTrue(EbftStatus.verify(this.ebftStatus3)); } |
### Question:
PbftBlockChain implements ConsensusBlockChain<PbftProto.PbftBlock, PbftMessage> { @Override public Map<String, List<String>> addBlock(ConsensusBlock<PbftProto.PbftBlock> block) { blockChainManagerMock.addBlock(block); this.blockKeyStore.put(block.getIndex(), block.getHash().getBytes()); loggingBlock((PbftBlock) block); return new HashMap<>(); } PbftBlockChain(Block genesisBlock, String dbPath,
String blockKeyStorePath, String blockStorePath); @Override BranchId getBranchId(); @Override Consensus getConsensus(); @Override PbftBlockKeyStore getBlockKeyStore(); @Override BlockChainManager<PbftProto.PbftBlock> getBlockChainManager(); @Override ContractManager getContractManager(); @Override PbftBlock getGenesisBlock(); @Override Map<String, PbftMessage> getUnConfirmedData(); @Override ReentrantLock getLock(); @Override Map<String, List<String>> addBlock(ConsensusBlock<PbftProto.PbftBlock> block); @Override Map<String, List<String>> addBlock(ConsensusBlock<PbftProto.PbftBlock> block, boolean broadcast); @Override boolean isValidator(String addr); @Override ValidatorSet getValidators(); }### Answer:
@Test public void addBlockTest() { this.pbftBlockChain.addBlock(pbftBlock1); assertEquals(1L, this.blockChainManager.getLastIndex()); this.pbftBlockChain.addBlock(pbftBlock2); assertEquals(2L, this.blockChainManager.getLastIndex()); this.pbftBlockChain.addBlock(pbftBlock3); assertEquals(3L, this.blockChainManager.getLastIndex()); } |
### Question:
PbftStatus { public Map<String, PbftMessage> getUnConfirmedPbftMessageMap() { return unConfirmedPbftMessageMap; } PbftStatus(long index,
Map<String, PbftMessage> unConfirmedPbftMessageMap,
long timestamp,
byte[] signature); PbftStatus(long index,
Map<String, PbftMessage> unConfirmedPbftMessageMap,
long timestamp,
Wallet wallet); PbftStatus(PbftProto.PbftStatus pbftStatus); private PbftStatus(JsonObject jsonObject); PbftStatus(byte[] bytes); long getIndex(); Map<String, PbftMessage> getUnConfirmedPbftMessageMap(); long getTimestamp(); byte[] getSignature(); byte[] getHashForSigning(); static boolean verify(PbftStatus status); static PbftProto.PbftStatus toProto(PbftStatus pbftStatus); JsonObject toJsonObject(); byte[] toBinary(); @Override boolean equals(Object o); @Override int hashCode(); void clear(); }### Answer:
@Test public void constuctorTest_Default() { assertEquals(1, pbftStatus.getUnConfirmedPbftMessageMap().size()); assertEquals(5, pbftStatus2.getUnConfirmedPbftMessageMap().size()); assertEquals(9, pbftStatus3.getUnConfirmedPbftMessageMap().size()); assertEquals(4, pbftStatus4.getUnConfirmedPbftMessageMap().size()); } |
### Question:
BlockApiImpl implements BlockApi { @Override public BlockDto getBlockByHash(String branchId, String blockId, Boolean bool) { ConsensusBlock block = branchGroup.getBlockByHash(BranchId.of(branchId), blockId); return BlockDto.createBy(block); } @Autowired BlockApiImpl(BranchGroup branchGroup); @Override long blockNumber(String branchId); @Override BlockDto getBlockByHash(String branchId, String blockId, Boolean bool); @Override BlockDto getBlockByNumber(String branchId, long numOfBlock, Boolean bool); @Override BlockDto getLastBlock(String branchId); }### Answer:
@Test public void getBlockByHashTest() { try { assertThat(BLOCK_API.getBlockByHash(branchId, "ad7dd0552336ebf3b2f4f648c4a87d7c35ed74382219e2954047ad9138a247c5", true)).isNotNull(); } catch (Exception exception) { log.debug("getBlockByHashTest :: exception : " + exception); } } |
### Question:
EbftBlockStore extends AbstractBlockStore<EbftProto.EbftBlock> { public EbftBlockStore(DbSource<byte[], byte[]> dbSource) { super(dbSource); } EbftBlockStore(DbSource<byte[], byte[]> dbSource); @Override EbftBlock get(Sha3Hash key); }### Answer:
@Test public void ebftBlockStoreTest() { LevelDbDataSource ds = new LevelDbDataSource(StoreTestUtils.getTestPath(), "block-con-store-test"); EbftBlockStore ebftBlockStore = new EbftBlockStore(ds); Block block = new TestUtils(wallet).sampleBlock(); List<ByteString> consensusList = new ArrayList<>(); consensusList.add(wallet.signByteString(block.getHash().getBytes(), true)); EbftBlock ebftBlock = new EbftBlock(block, consensusList); ebftBlockStore.put(ebftBlock.getHash(), ebftBlock); EbftBlock foundEbftBlock = ebftBlockStore.get(ebftBlock.getHash()); assert (ebftBlock.equals(foundEbftBlock)); assert (ebftBlockStore.contains(ebftBlock.getHash())); log.debug("size: {}", ebftBlockStore.size()); assertEquals(1, ebftBlockStore.size()); StoreTestUtils.clearTestDb(); } |
### Question:
EbftBlockKeyStore implements BlockKeyStore<Long, byte[]> { @Override public byte[] get(Long key) { if (key < 0) { log.debug("Key is not vaild."); return null; } lock.lock(); try { log.trace("get " + "({})", key); return db.get(ByteUtil.longToBytes(key)); } catch (Exception e) { log.debug(e.getMessage()); return null; } finally { lock.unlock(); } } EbftBlockKeyStore(DbSource<byte[], byte[]> dbSource); @Override void put(Long key, byte[] value); @Override byte[] get(Long key); @Override boolean contains(Long key); @Override long size(); @Override void close(); }### Answer:
@Test public void getTest_NegativeNumber() { assertNull(blockKeyStore.get(-1L)); } |
### Question:
EbftBlockKeyStore implements BlockKeyStore<Long, byte[]> { @Override public void close() { lock.lock(); try { this.db.close(); } finally { lock.unlock(); } } EbftBlockKeyStore(DbSource<byte[], byte[]> dbSource); @Override void put(Long key, byte[] value); @Override byte[] get(Long key); @Override boolean contains(Long key); @Override long size(); @Override void close(); }### Answer:
@Test public void closeTest() { blockKeyStore.close(); TestCase.assertNull(blockKeyStore.get(this.ebftBlock.getIndex())); this.blockKeyStore = new EbftBlockKeyStore(ds); byte[] newHash = blockKeyStore.get(0L); assertArrayEquals(this.ebftBlock.getHash().getBytes(), newHash); } |
### Question:
PbftBlockKeyStore implements BlockKeyStore<Long, byte[]> { @Override public byte[] get(Long key) { if (key < 0) { log.debug("Key is not vaild."); return null; } lock.lock(); try { log.trace("get ({})", key); return db.get(ByteUtil.longToBytes(key)); } catch (Exception e) { log.debug(e.getMessage()); return null; } finally { lock.unlock(); } } PbftBlockKeyStore(DbSource<byte[], byte[]> dbSource); @Override void put(Long key, byte[] value); @Override byte[] get(Long key); @Override boolean contains(Long key); @Override long size(); @Override void close(); }### Answer:
@Test public void getTest_NegativeNumber() { assertNull(blockKeyStore.get(-1L)); } |
### Question:
PbftBlockKeyStore implements BlockKeyStore<Long, byte[]> { @Override public void close() { lock.lock(); try { this.db.close(); } finally { lock.unlock(); } } PbftBlockKeyStore(DbSource<byte[], byte[]> dbSource); @Override void put(Long key, byte[] value); @Override byte[] get(Long key); @Override boolean contains(Long key); @Override long size(); @Override void close(); }### Answer:
@Test public void closeTest() { blockKeyStore.close(); TestCase.assertNull(blockKeyStore.get(this.pbftBlock0.getIndex())); this.blockKeyStore = new PbftBlockKeyStore(ds); byte[] newHash = blockKeyStore.get(0L); assertArrayEquals(this.pbftBlock0.getHash().getBytes(), newHash); } |
### Question:
BlockApiImpl implements BlockApi { @Override public BlockDto getBlockByNumber(String branchId, long numOfBlock, Boolean bool) { ConsensusBlock block = branchGroup.getBlockByIndex(BranchId.of(branchId), numOfBlock); return BlockDto.createBy(block); } @Autowired BlockApiImpl(BranchGroup branchGroup); @Override long blockNumber(String branchId); @Override BlockDto getBlockByHash(String branchId, String blockId, Boolean bool); @Override BlockDto getBlockByNumber(String branchId, long numOfBlock, Boolean bool); @Override BlockDto getLastBlock(String branchId); }### Answer:
@Test public void getBlockByNumberTest() { try { assertThat(BLOCK_API.getBlockByNumber(branchId, 0, true)).isNotNull(); } catch (Exception exception) { log.debug("getBlockByNumberTest :: exception : " + exception); } } |
### Question:
SerializationUtil { public static byte[] serializeString(String string) { return string.getBytes(DEFAULT_CHARSET); } private SerializationUtil(); static byte[] serializeJson(JsonElement json); static byte[] serializeString(String string); static String deserializeString(byte[] data); }### Answer:
@Test public void serializeString() { String str = "{type:트랜잭션}"; Assert.assertEquals(11, str.length()); byte[] data = SerializationUtil.serializeString(str); Assert.assertEquals(19, data.length); Assert.assertEquals(str, SerializationUtil.deserializeString(data)); } |
### Question:
Keccak512 extends KeccakCore { public Digest copy() { return copyState(new Keccak512()); } Keccak512(); Digest copy(); @Override int engineGetDigestLength(); }### Answer:
@Test public void copy() { Digest digest = keccak512.copy(); Assert.assertNotNull(digest); } |
### Question:
Keccak512 extends KeccakCore { @Override public int engineGetDigestLength() { return 64; } Keccak512(); Digest copy(); @Override int engineGetDigestLength(); }### Answer:
@Test public void engineGetDigestLength() { Assert.assertEquals(64, keccak512.engineGetDigestLength()); } |
### Question:
Keccak512 extends KeccakCore { @Override protected byte[] engineDigest() { return null; } Keccak512(); Digest copy(); @Override int engineGetDigestLength(); }### Answer:
@Test public void engineDigest() { Assert.assertNull(keccak512.engineDigest()); } |
### Question:
Keccak512 extends KeccakCore { @Override protected void engineUpdate(byte input) { } Keccak512(); Digest copy(); @Override int engineGetDigestLength(); }### Answer:
@Test public void engineUpdate() { keccak512.engineUpdate((byte) 'b'); keccak512.engineUpdate("byte".getBytes(), 0, 4); } |
### Question:
ECIESPublicKeyEncoder implements KeyEncoder { @Override public byte[] getEncoded(AsymmetricKeyParameter asymmetricKeyParameter) { return ((ECPublicKeyParameters) asymmetricKeyParameter).getQ().getEncoded(false); } @Override byte[] getEncoded(AsymmetricKeyParameter asymmetricKeyParameter); }### Answer:
@Test public void getEncoded() { ECPublicKeyParameters param = new ECPublicKeyParameters(CURVE.getCurve().decodePoint(pubKey), CURVE); ECIESPublicKeyEncoder encoder = new ECIESPublicKeyEncoder(); Assert.assertNotNull(encoder.getEncoded(param)); } |
### Question:
MGF1BytesGeneratorExt implements DerivationFunction { public Digest getDigest() { return this.digest; } MGF1BytesGeneratorExt(Digest digest, int counterStart); void init(DerivationParameters param); Digest getDigest(); int generateBytes(byte[] out, int outOff, int len); }### Answer:
@Test public void getDigest() { MGF1BytesGeneratorExt ext = new MGF1BytesGeneratorExt(new SHA1Digest(), 1); byte[] VZ = BigIntegers.asUnsignedByteArray(1, BigInteger.ONE); DerivationParameters kdfParam = new MGFParameters(VZ); ext.init(kdfParam); byte[] K1 = new byte[4]; assert ext.generateBytes(K1, 0, K1.length) > 0; Assert.assertNotNull(ext.getDigest()); } |
### Question:
BiUtil { public static boolean isZero(BigInteger value) { return value.compareTo(BigInteger.ZERO) == 0; } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void isZero() { Assert.assertTrue(BiUtil.isZero(BigInteger.ZERO)); } |
### Question:
BiUtil { public static boolean isEqual(BigInteger valueA, BigInteger valueB) { return valueA.compareTo(valueB) == 0; } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void isEqual() { Assert.assertTrue(BiUtil.isEqual(BigInteger.ONE, BigInteger.ONE)); } |
### Question:
BranchApiImpl implements BranchApi { @Override public Map<String, BranchDto> getBranches() { Map<String, BranchDto> branchMap = new HashMap<>(); branchGroup.getAllBranch().forEach(blockChain -> branchMap.put(blockChain.getBranchId().toString(), BranchDto.of(blockChain.getBranch().getJson()))); return branchMap; } @Autowired BranchApiImpl(BranchGroup branchGroup); @Override Map<String, BranchDto> getBranches(); @Override Set<String> getValidators(String branchId); }### Answer:
@Test public void getBranchesTest() { try { assertThat(BRANCH_API.getBranches()).isNotNull(); } catch (Exception exception) { log.debug("getBranchesTest :: exception : " + exception); } } |
### Question:
BiUtil { public static boolean isNotEqual(BigInteger valueA, BigInteger valueB) { return !isEqual(valueA, valueB); } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void isNotEqual() { Assert.assertTrue(BiUtil.isNotEqual(BigInteger.ZERO, BigInteger.ONE)); } |
### Question:
BiUtil { public static boolean isLessThan(BigInteger valueA, BigInteger valueB) { return valueA.compareTo(valueB) < 0; } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void isLessThan() { Assert.assertTrue(BiUtil.isLessThan(BigInteger.ZERO, BigInteger.ONE)); } |
### Question:
BiUtil { public static boolean isMoreThan(BigInteger valueA, BigInteger valueB) { return valueA.compareTo(valueB) > 0; } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void isMoreThan() { Assert.assertTrue(BiUtil.isMoreThan(BigInteger.ONE, BigInteger.ZERO)); } |
### Question:
BiUtil { public static BigInteger sum(BigInteger valueA, BigInteger valueB) { return valueA.add(valueB); } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void sum() { Assert.assertEquals(11, BiUtil.sum(BigInteger.ONE, BigInteger.TEN).intValue()); } |
### Question:
BiUtil { public static BigInteger toBi(long data) { return BigInteger.valueOf(data); } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void toBi() { Assert.assertEquals(BigInteger.ONE, BiUtil.toBi(1)); } |
### Question:
BiUtil { public static boolean isPositive(BigInteger value) { return value.signum() > 0; } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void isPositive() { Assert.assertTrue(BiUtil.isPositive(BigInteger.ONE)); } |
### Question:
BiUtil { public static boolean isCovers(BigInteger covers, BigInteger value) { return !isNotCovers(covers, value); } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void isCovers() { Assert.assertTrue(BiUtil.isCovers(BigInteger.ONE, BigInteger.ZERO)); } |
### Question:
BiUtil { public static boolean isNotCovers(BigInteger covers, BigInteger value) { return covers.compareTo(value) < 0; } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void isNotCovers() { Assert.assertTrue(BiUtil.isNotCovers(BigInteger.ZERO, BigInteger.ONE)); } |
### Question:
BiUtil { public static boolean exitLong(BigInteger value) { return (value.compareTo(new BigInteger(Long.MAX_VALUE + ""))) > -1; } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void exitLong() { Assert.assertTrue(BiUtil.exitLong(new BigInteger(Long.MAX_VALUE + ""))); } |
### Question:
BiUtil { public static boolean isIn20PercentRange(BigInteger first, BigInteger second) { BigInteger five = BigInteger.valueOf(5); BigInteger limit = first.add(first.divide(five)); return !isMoreThan(second, limit); } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void isIn20PercentRange() { Assert.assertTrue(BiUtil.isIn20PercentRange(BigInteger.valueOf(5), BigInteger.ONE)); } |
### Question:
BranchApiImpl implements BranchApi { @Override public Set<String> getValidators(String branchId) { BlockChain bc = branchGroup.getBranch(BranchId.of(branchId)); ValidatorSet validators = bc.getValidators(); if (validators == null) { throw new NonExistObjectException.TxNotFound(); } return validators.getValidatorMap().keySet(); } @Autowired BranchApiImpl(BranchGroup branchGroup); @Override Map<String, BranchDto> getBranches(); @Override Set<String> getValidators(String branchId); }### Answer:
@Test public void getValidatorsTest() { try { assertThat(BRANCH_API.getValidators(branchId)).isNotNull(); } catch (Exception exception) { log.debug("getValidatorsTest :: exception : " + exception); } } |
### Question:
BiUtil { public static BigInteger max(BigInteger first, BigInteger second) { return first.compareTo(second) < 0 ? second : first; } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void max() { Assert.assertEquals(BigInteger.ONE, BiUtil.max(BigInteger.ONE, BigInteger.ZERO)); } |
### Question:
BiUtil { public static int addSafely(int a, int b) { long res = (long) a + (long) b; return res > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) res; } private BiUtil(); static boolean isZero(BigInteger value); static boolean isEqual(BigInteger valueA, BigInteger valueB); static boolean isNotEqual(BigInteger valueA, BigInteger valueB); static boolean isLessThan(BigInteger valueA, BigInteger valueB); static boolean isMoreThan(BigInteger valueA, BigInteger valueB); static BigInteger sum(BigInteger valueA, BigInteger valueB); static BigInteger toBi(long data); static boolean isPositive(BigInteger value); static boolean isCovers(BigInteger covers, BigInteger value); static boolean isNotCovers(BigInteger covers, BigInteger value); static boolean exitLong(BigInteger value); static boolean isIn20PercentRange(BigInteger first, BigInteger second); static BigInteger max(BigInteger first, BigInteger second); static int addSafely(int a, int b); }### Answer:
@Test public void addSafely() { Assert.assertEquals(10,BiUtil.addSafely(1, 9)); } |
### Question:
Utils { public static String longToTimePeriod(long msec) { if (msec < 1000) { return msec + "ms"; } if (msec < 3000) { return String.format("%.2fs", msec / 1000d); } if (msec < 60 * 1000) { return (msec / 1000) + "s"; } long sec = msec / 1000; if (sec < 5 * 60) { return (sec / 60) + "m" + (sec % 60) + "s"; } long min = sec / 60; if (min < 60) { return min + "m"; } long hour = min / 60; if (min < 24 * 60) { return hour + "h" + (min % 60) + "m"; } long day = hour / 24; return day + "d" + (day % 24) + "h"; } static String longToTimePeriod(long msec); static SecureRandom getRandom(); static String getNodeIdShort(String nodeId); static long toUnixTime(long javaTime); static long fromUnixTime(long unixTime); @SafeVarargs static T[] mergeArrays(T[]... arr); static String align(String s, char fillChar, int targetLen, boolean alignRight); static String repeat(String s, int n); static void showErrorAndExit(String message, String... messages); static void showWarn(String message, String... messages); static String sizeToStr(long size); static void sleep(long ms); @Deprecated static long time(); }### Answer:
@Test public void longToTimePeriod() { Assert.assertEquals("1ms", Utils.longToTimePeriod(1)); } |
### Question:
Utils { public static SecureRandom getRandom() { return random; } static String longToTimePeriod(long msec); static SecureRandom getRandom(); static String getNodeIdShort(String nodeId); static long toUnixTime(long javaTime); static long fromUnixTime(long unixTime); @SafeVarargs static T[] mergeArrays(T[]... arr); static String align(String s, char fillChar, int targetLen, boolean alignRight); static String repeat(String s, int n); static void showErrorAndExit(String message, String... messages); static void showWarn(String message, String... messages); static String sizeToStr(long size); static void sleep(long ms); @Deprecated static long time(); }### Answer:
@Test public void getRandom() { Assert.assertNotNull(Utils.getRandom()); } |
### Question:
Utils { static double getJavaVersion() { String version = System.getProperty("java.version"); if (version.equals("0")) { return 0; } if (version.contains("-")) { int indexOfDash = version.indexOf("-"); return Double.parseDouble(version.substring(0, indexOfDash)); } if (!version.contains(".")) { return Double.parseDouble(version); } int pos = 0, count = 0; for (; pos < version.length() && count < 2; pos++) { if (version.charAt(pos) == '.') { count++; } } return Double.parseDouble(version.substring(0, pos - 1)); } static String longToTimePeriod(long msec); static SecureRandom getRandom(); static String getNodeIdShort(String nodeId); static long toUnixTime(long javaTime); static long fromUnixTime(long unixTime); @SafeVarargs static T[] mergeArrays(T[]... arr); static String align(String s, char fillChar, int targetLen, boolean alignRight); static String repeat(String s, int n); static void showErrorAndExit(String message, String... messages); static void showWarn(String message, String... messages); static String sizeToStr(long size); static void sleep(long ms); @Deprecated static long time(); }### Answer:
@Test public void getJavaVersion() { Assert.assertTrue(Utils.getJavaVersion() > 1); } |
### Question:
Utils { public static String getNodeIdShort(String nodeId) { return nodeId == null ? "<null>" : nodeId.substring(0, 8); } static String longToTimePeriod(long msec); static SecureRandom getRandom(); static String getNodeIdShort(String nodeId); static long toUnixTime(long javaTime); static long fromUnixTime(long unixTime); @SafeVarargs static T[] mergeArrays(T[]... arr); static String align(String s, char fillChar, int targetLen, boolean alignRight); static String repeat(String s, int n); static void showErrorAndExit(String message, String... messages); static void showWarn(String message, String... messages); static String sizeToStr(long size); static void sleep(long ms); @Deprecated static long time(); }### Answer:
@Test public void getNodeIdShort() { Assert.assertEquals("abcdefgh", Utils.getNodeIdShort("abcdefghijkl")); Assert.assertEquals("<null>", Utils.getNodeIdShort(null)); } |
### Question:
Utils { public static long toUnixTime(long javaTime) { return javaTime / 1000; } static String longToTimePeriod(long msec); static SecureRandom getRandom(); static String getNodeIdShort(String nodeId); static long toUnixTime(long javaTime); static long fromUnixTime(long unixTime); @SafeVarargs static T[] mergeArrays(T[]... arr); static String align(String s, char fillChar, int targetLen, boolean alignRight); static String repeat(String s, int n); static void showErrorAndExit(String message, String... messages); static void showWarn(String message, String... messages); static String sizeToStr(long size); static void sleep(long ms); @Deprecated static long time(); }### Answer:
@Test public void toUnixTime() { Assert.assertEquals(1, Utils.toUnixTime(1000)); } |
### Question:
Utils { public static long fromUnixTime(long unixTime) { return unixTime * 1000; } static String longToTimePeriod(long msec); static SecureRandom getRandom(); static String getNodeIdShort(String nodeId); static long toUnixTime(long javaTime); static long fromUnixTime(long unixTime); @SafeVarargs static T[] mergeArrays(T[]... arr); static String align(String s, char fillChar, int targetLen, boolean alignRight); static String repeat(String s, int n); static void showErrorAndExit(String message, String... messages); static void showWarn(String message, String... messages); static String sizeToStr(long size); static void sleep(long ms); @Deprecated static long time(); }### Answer:
@Test public void fromUnixTime() { Assert.assertEquals(1000, Utils.fromUnixTime(1)); } |
### Question:
Utils { @SafeVarargs public static <T> T[] mergeArrays(T[]... arr) { int size = 0; for (T[] ts : arr) { size += ts.length; } @SuppressWarnings("unchecked") T[] ret = (T[]) Array.newInstance(arr[0].getClass().getComponentType(), size); int off = 0; for (T[] ts : arr) { System.arraycopy(ts, 0, ret, off, ts.length); off += ts.length; } return ret; } static String longToTimePeriod(long msec); static SecureRandom getRandom(); static String getNodeIdShort(String nodeId); static long toUnixTime(long javaTime); static long fromUnixTime(long unixTime); @SafeVarargs static T[] mergeArrays(T[]... arr); static String align(String s, char fillChar, int targetLen, boolean alignRight); static String repeat(String s, int n); static void showErrorAndExit(String message, String... messages); static void showWarn(String message, String... messages); static String sizeToStr(long size); static void sleep(long ms); @Deprecated static long time(); }### Answer:
@Test public void mergeArrays() { Assert.assertEquals(2, Utils.mergeArrays(new String[] {"a", "b"}).length); } |
### Question:
Utils { public static String align(String s, char fillChar, int targetLen, boolean alignRight) { if (targetLen <= s.length()) { return s; } String alignString = repeat("" + fillChar, targetLen - s.length()); return alignRight ? alignString + s : s + alignString; } static String longToTimePeriod(long msec); static SecureRandom getRandom(); static String getNodeIdShort(String nodeId); static long toUnixTime(long javaTime); static long fromUnixTime(long unixTime); @SafeVarargs static T[] mergeArrays(T[]... arr); static String align(String s, char fillChar, int targetLen, boolean alignRight); static String repeat(String s, int n); static void showErrorAndExit(String message, String... messages); static void showWarn(String message, String... messages); static String sizeToStr(long size); static void sleep(long ms); @Deprecated static long time(); }### Answer:
@Test public void align() { Assert.assertEquals("test", Utils.align("test", 'c', 1, true)); Assert.assertEquals("00test", Utils.align("test", '0', 6, true)); } |
### Question:
LogApiImpl implements LogApi { @Override public Log getLog(String branchId, long index) { return branchGroup.getBranch(BranchId.of(branchId)).getContractManager().getLog(index); } @Autowired LogApiImpl(BranchGroup branchGroup); @Override Log getLog(String branchId, long index); @Override List<Log> getLogs(String branchId, long start, long offset); @Override List<Log> getLogs(String branchId, String regex, long start, long offset); @Override long curIndex(String branchId); }### Answer:
@Test public void getLogJsonRpcTest() { try { LOG_API.getLog(branchId, 0); } catch (Exception e) { log.debug("getLogTest :: ERR => {}", e.getMessage()); } } |
### Question:
Utils { public static String repeat(String s, int n) { if (s.length() == 1) { byte[] bb = new byte[n]; Arrays.fill(bb, s.getBytes()[0]); String result = new String(bb); bb = null; return result; } else { StringBuilder ret = new StringBuilder(); for (int i = 0; i < n; i++) { ret.append(s); } return ret.toString(); } } static String longToTimePeriod(long msec); static SecureRandom getRandom(); static String getNodeIdShort(String nodeId); static long toUnixTime(long javaTime); static long fromUnixTime(long unixTime); @SafeVarargs static T[] mergeArrays(T[]... arr); static String align(String s, char fillChar, int targetLen, boolean alignRight); static String repeat(String s, int n); static void showErrorAndExit(String message, String... messages); static void showWarn(String message, String... messages); static String sizeToStr(long size); static void sleep(long ms); @Deprecated static long time(); }### Answer:
@Test public void repeat() { Assert.assertEquals("aa", Utils.repeat("a", 2)); } |
### Question:
Utils { public static void showErrorAndExit(String message, String... messages) { LoggerFactory.getLogger("general").error(message); final String ANSI_RED = "\u001B[31m"; final String ANSI_RESET = "\u001B[0m"; System.err.println(ANSI_RED); System.err.println(); System.err.println(" " + message); for (String msg : messages) { System.err.println(" " + msg); } System.err.println(); System.err.println(ANSI_RESET); throw new RuntimeException(message); } static String longToTimePeriod(long msec); static SecureRandom getRandom(); static String getNodeIdShort(String nodeId); static long toUnixTime(long javaTime); static long fromUnixTime(long unixTime); @SafeVarargs static T[] mergeArrays(T[]... arr); static String align(String s, char fillChar, int targetLen, boolean alignRight); static String repeat(String s, int n); static void showErrorAndExit(String message, String... messages); static void showWarn(String message, String... messages); static String sizeToStr(long size); static void sleep(long ms); @Deprecated static long time(); }### Answer:
@Test(expected = RuntimeException.class) public void showErrorAndExit() { Utils.showErrorAndExit("test"); } |
### Question:
Utils { public static void showWarn(String message, String... messages) { LoggerFactory.getLogger("general").warn(message); final String ANSI_RED = "\u001B[31m"; final String ANSI_RESET = "\u001B[0m"; System.err.println(ANSI_RED); System.err.println(); System.err.println(" " + message); for (String msg : messages) { System.err.println(" " + msg); } System.err.println(); System.err.println(ANSI_RESET); } static String longToTimePeriod(long msec); static SecureRandom getRandom(); static String getNodeIdShort(String nodeId); static long toUnixTime(long javaTime); static long fromUnixTime(long unixTime); @SafeVarargs static T[] mergeArrays(T[]... arr); static String align(String s, char fillChar, int targetLen, boolean alignRight); static String repeat(String s, int n); static void showErrorAndExit(String message, String... messages); static void showWarn(String message, String... messages); static String sizeToStr(long size); static void sleep(long ms); @Deprecated static long time(); }### Answer:
@Test public void showWarn() { Utils.showWarn("test"); } |
### Question:
Utils { public static String sizeToStr(long size) { if (size < 2 * (1L << 10)) { return size + "b"; } if (size < 2 * (1L << 20)) { return String.format("%dKb", size / (1L << 10)); } if (size < 2 * (1L << 30)) { return String.format("%dMb", size / (1L << 20)); } return String.format("%dGb", size / (1L << 30)); } static String longToTimePeriod(long msec); static SecureRandom getRandom(); static String getNodeIdShort(String nodeId); static long toUnixTime(long javaTime); static long fromUnixTime(long unixTime); @SafeVarargs static T[] mergeArrays(T[]... arr); static String align(String s, char fillChar, int targetLen, boolean alignRight); static String repeat(String s, int n); static void showErrorAndExit(String message, String... messages); static void showWarn(String message, String... messages); static String sizeToStr(long size); static void sleep(long ms); @Deprecated static long time(); }### Answer:
@Test public void sizeToStr() { Assert.assertEquals("1b", Utils.sizeToStr(1)); } |
### Question:
DefaultConfig { public DefaultConfig() { this(ConfigFactory.empty()); } DefaultConfig(); DefaultConfig(boolean productionMode); DefaultConfig(Config apiConfig); DefaultConfig(Config apiConfig, boolean productionMode); Config getConfig(); String getString(String path); int getInt(String path); String toString(); boolean isProductionMode(); String getKeyPath(); String getKeyPassword(); Network getNetwork(); String getNetworkP2PVersion(); String getDatabasePath(); String getContractPath(); String getOsgiPath(); String getBranchPath(); String getYggDataPath(); String getValidatorPath(); String getContractRepositoryUrl(); void setConfig(Config config); }### Answer:
@Test public void defaultConfigTest() { log.debug(defaultConfig.toString()); assertThat(defaultConfig.getString("java.vm.version")).isNotEmpty(); log.debug("DefaultConfig java.vm.version: " + defaultConfig.getString("java.vm.version")); assertThat(defaultConfig.getString(Constants.NODE_GRPC_PORT)).isEqualTo("32918"); log.debug("DefaultConfig {}: {}", Constants.NODE_GRPC_PORT, defaultConfig.getString(Constants.NODE_GRPC_PORT)); } |
### Question:
DefaultConfig { public String getString(String path) { return config.getString(path); } DefaultConfig(); DefaultConfig(boolean productionMode); DefaultConfig(Config apiConfig); DefaultConfig(Config apiConfig, boolean productionMode); Config getConfig(); String getString(String path); int getInt(String path); String toString(); boolean isProductionMode(); String getKeyPath(); String getKeyPassword(); Network getNetwork(); String getNetworkP2PVersion(); String getDatabasePath(); String getContractPath(); String getOsgiPath(); String getBranchPath(); String getYggDataPath(); String getValidatorPath(); String getContractRepositoryUrl(); void setConfig(Config config); }### Answer:
@Test public void newConfigFileTest() { Config config = ConfigFactory.parseResources("yggdrash_sample.conf"); DefaultConfig defaultConfig = new DefaultConfig(config); assertThat(defaultConfig.getString(Constants.YGGDRASH_KEY_PATH)).endsWith("nodePri2.key"); log.debug("newConfigFile key.path: " + defaultConfig.getString(Constants.YGGDRASH_KEY_PATH)); } |
### Question:
TimeComparator implements Comparator<Peer> { @Override public int compare(Peer p1, Peer p2) { long t1 = p1.getModified(); long t2 = p2.getModified(); return Long.compare(t2, t1); } @Override int compare(Peer p1, Peer p2); }### Answer:
@Test public void compareTest() { TimeComparator timeComparator = new TimeComparator(); Peer p1 = Peer.valueOf("ynode: Utils.sleep(1); Peer p2 = Peer.valueOf("ynode: long earlyJoinPeer = p1.getModified(); long latestJoinPeer = p2.getModified(); Assert.assertTrue(earlyJoinPeer < latestJoinPeer); Assert.assertTrue(timeComparator.compare(p1, p2) > 0); ArrayList<Peer> peerArrayList = new ArrayList<>(); peerArrayList.add(p1); peerArrayList.add(p2); peerArrayList.sort(timeComparator); Assert.assertEquals(p2, peerArrayList.get(0)); } |
### Question:
Peer { public static Peer valueOf(String ynodeUri) { return new Peer(ynodeUri); } private Peer(String ynodeUri); static Peer valueOf(String ynodeUri); static Peer valueOf(byte[] ynodeUriBytes); static Peer valueOf(String nodeId, String host, int port); PeerId getPeerId(); Sha3Hash getPubKey(); String getHost(); int getPort(); String getYnodeUri(); long getBestBlock(); void setBestBlock(long bestBlock); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); String toAddress(); }### Answer:
@Test(expected = NotValidateException.class) public void unknownSchemaTest() { Peer.valueOf("http: } |
### Question:
Peer { @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } Peer peer = (Peer) o; return peerId.equals(peer.getPeerId()); } private Peer(String ynodeUri); static Peer valueOf(String ynodeUri); static Peer valueOf(byte[] ynodeUriBytes); static Peer valueOf(String nodeId, String host, int port); PeerId getPeerId(); Sha3Hash getPubKey(); String getHost(); int getPort(); String getYnodeUri(); long getBestBlock(); void setBestBlock(long bestBlock); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); String toAddress(); }### Answer:
@Test public void equalsTest() { Peer peer1 = Peer.valueOf("ynode: assertThat(peer1).isEqualTo(Peer.valueOf("ynode: Peer peer2 = Peer.valueOf("ynode: assertThat(peer1).isNotEqualTo(peer2); } |
### Question:
Peer { boolean isLocal() { return host.equals("127.0.0.1") || host.equals("localhost"); } private Peer(String ynodeUri); static Peer valueOf(String ynodeUri); static Peer valueOf(byte[] ynodeUriBytes); static Peer valueOf(String nodeId, String host, int port); PeerId getPeerId(); Sha3Hash getPubKey(); String getHost(); int getPort(); String getYnodeUri(); long getBestBlock(); void setBestBlock(long bestBlock); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); String toAddress(); }### Answer:
@Test public void isLocalTest() { assertThat(Peer.valueOf("ynode: assertThat(Peer.valueOf("ynode: assertThat(Peer.valueOf("ynode: } |
### Question:
DexTransferMoneyTransaction extends DEX { @Override public AbstractAttachment parseAttachment(ByteBuffer buffer) throws AplException.NotValidException { return new DexControlOfFrozenMoneyAttachment(buffer); } @Override byte getSubtype(); @Override LedgerEvent getLedgerEvent(); @Override AbstractAttachment parseAttachment(ByteBuffer buffer); @Override AbstractAttachment parseAttachment(JSONObject attachmentData); @Override void validateAttachment(Transaction transaction); @Override boolean applyAttachmentUnconfirmed(Transaction transaction, Account senderAccount); @Override void applyAttachment(Transaction tx, Account sender, Account recipient); @Override void undoAttachmentUnconfirmed(Transaction transaction, Account senderAccount); @Override boolean isDuplicate(Transaction transaction, Map<TransactionType, Map<String, Integer>> duplicates); @Override boolean canHaveRecipient(); @Override boolean isPhasingSafe(); @Override String getName(); }### Answer:
@Test void testSerializeDeserializeAttachmentToJson() throws AplException.NotValidException { JSONObject jsonObject = attachment.getJSONObject(); AbstractAttachment parsedAttachment = transactionType.parseAttachment(jsonObject); assertEquals(attachment, parsedAttachment); }
@Test void parseByteAttachment() throws AplException.NotValidException { ByteBuffer buffer = ByteBuffer.allocate(17); buffer.put((byte) 1); buffer.putLong(64); buffer.putLong(100); buffer.rewind(); AbstractAttachment parsedAttachment = transactionType.parseAttachment(buffer); assertEquals(attachment, parsedAttachment); }
@Test void testJsonParseAttachment() throws AplException.NotValidException { JSONObject jsonObject = new JSONObject(); jsonObject.put("contractId", 64L); jsonObject.put("offerAmount", 100L); jsonObject.put("version.DexTransferMoney", 1); AbstractAttachment parsedAttachment = transactionType.parseAttachment(jsonObject); assertEquals(attachment, parsedAttachment); }
@Test void testSerializeDeserializeAttachmentToByteBuffer() throws AplException.NotValidException { int myFullSize = attachment.getFullSize(); ByteBuffer buffer = ByteBuffer.allocate(myFullSize); attachment.putBytes(buffer); buffer.rewind(); AbstractAttachment parsedAttachment = transactionType.parseAttachment(buffer); assertEquals(attachment, parsedAttachment); } |
### Question:
DexTransferMoneyTransaction extends DEX { @Override public boolean isDuplicate(Transaction transaction, Map<TransactionType, Map<String, Integer>> duplicates) { DexControlOfFrozenMoneyAttachment attachment = (DexControlOfFrozenMoneyAttachment) transaction.getAttachment(); return isDuplicate(DEX.DEX_TRANSFER_MONEY_TRANSACTION, Long.toUnsignedString(attachment.getContractId()), duplicates, true); } @Override byte getSubtype(); @Override LedgerEvent getLedgerEvent(); @Override AbstractAttachment parseAttachment(ByteBuffer buffer); @Override AbstractAttachment parseAttachment(JSONObject attachmentData); @Override void validateAttachment(Transaction transaction); @Override boolean applyAttachmentUnconfirmed(Transaction transaction, Account senderAccount); @Override void applyAttachment(Transaction tx, Account sender, Account recipient); @Override void undoAttachmentUnconfirmed(Transaction transaction, Account senderAccount); @Override boolean isDuplicate(Transaction transaction, Map<TransactionType, Map<String, Integer>> duplicates); @Override boolean canHaveRecipient(); @Override boolean isPhasingSafe(); @Override String getName(); }### Answer:
@Test void testIsDuplicate() { Transaction tx = mock(Transaction.class); doReturn(attachment).when(tx).getAttachment(); Map<TransactionType, Map<String, Integer>> duplicates = new HashMap<>(); assertFalse(transactionType.isDuplicate(tx, duplicates)); assertTrue(transactionType.isDuplicate(tx, duplicates)); } |
### Question:
DexCloseOrderTransaction extends DEX { @Override public AbstractAttachment parseAttachment(ByteBuffer buffer) throws AplException.NotValidException { return new DexCloseOrderAttachment(buffer); } @Override byte getSubtype(); @Override LedgerEvent getLedgerEvent(); @Override AbstractAttachment parseAttachment(ByteBuffer buffer); @Override AbstractAttachment parseAttachment(JSONObject attachmentData); @Override void validateAttachment(Transaction tx); @Override boolean applyAttachmentUnconfirmed(Transaction transaction, Account senderAccount); @Override void applyAttachment(Transaction transaction, Account senderAccount, Account recipientAccount); @Override void undoAttachmentUnconfirmed(Transaction transaction, Account senderAccount); @Override boolean isDuplicate(Transaction transaction, Map<TransactionType, Map<String, Integer>> duplicates); @Override boolean canHaveRecipient(); @Override boolean isPhasingSafe(); @Override String getName(); }### Answer:
@Test void testParseAttachmentFromByteBuffer() throws AplException.NotValidException { ByteBuffer buffer = ByteBuffer.allocate(9); buffer.put((byte) 1); buffer.putLong(10); buffer.rewind(); AbstractAttachment parsedAttachment = transactionType.parseAttachment(buffer); assertEquals(attachment, parsedAttachment); }
@Test void testParseAttachmentFromJson() throws AplException.NotValidException { JSONObject object = new JSONObject(); object.put("version.DexCloseOrder", 1); object.put("contractId", "10"); AbstractAttachment parsedAttachment = transactionType.parseAttachment(object); assertEquals(attachment, parsedAttachment); }
@Test void testSerializeDeserializeToBytes() throws AplException.NotValidException { ByteBuffer buffer = ByteBuffer.allocate(9); attachment.putBytes(buffer); buffer.rewind(); AbstractAttachment parsedAttachment = transactionType.parseAttachment(buffer); assertEquals(attachment, parsedAttachment); }
@Test void testSerializeDeserializeToJson() throws AplException.NotValidException { JSONObject json = attachment.getJSONObject(); AbstractAttachment parsedAttachment = transactionType.parseAttachment(json); assertEquals(attachment, parsedAttachment); } |
### Question:
DexCloseOrderTransaction extends DEX { @Override public void applyAttachment(Transaction transaction, Account senderAccount, Account recipientAccount) { DexCloseOrderAttachment attachment = (DexCloseOrderAttachment) transaction.getAttachment(); DexService dexService = lookupDexService(); ExchangeContract contract = dexService.getDexContractById(attachment.getContractId()); long orderId = senderAccount.getId() == contract.getSender() ? contract.getOrderId() : contract.getCounterOrderId(); dexService.closeOrder(orderId); } @Override byte getSubtype(); @Override LedgerEvent getLedgerEvent(); @Override AbstractAttachment parseAttachment(ByteBuffer buffer); @Override AbstractAttachment parseAttachment(JSONObject attachmentData); @Override void validateAttachment(Transaction tx); @Override boolean applyAttachmentUnconfirmed(Transaction transaction, Account senderAccount); @Override void applyAttachment(Transaction transaction, Account senderAccount, Account recipientAccount); @Override void undoAttachmentUnconfirmed(Transaction transaction, Account senderAccount); @Override boolean isDuplicate(Transaction transaction, Map<TransactionType, Map<String, Integer>> duplicates); @Override boolean canHaveRecipient(); @Override boolean isPhasingSafe(); @Override String getName(); }### Answer:
@Test void testApplyAttachment() { Transaction tx = mock(Transaction.class); doReturn(attachment).when(tx).getAttachment(); doReturn(contract).when(dexService).getDexContractById(10L); Account sender = mock(Account.class); doReturn(1000L).when(sender).getId(); transactionType.applyAttachment(tx, sender, null); verify(dexService).closeOrder(200); doReturn(2000L).when(sender).getId(); transactionType.applyAttachment(tx, sender, null); verify(dexService).closeOrder(200); } |
### Question:
DexCloseOrderTransaction extends DEX { @Override public boolean isDuplicate(Transaction transaction, Map<TransactionType, Map<String, Integer>> duplicates) { DexCloseOrderAttachment attachment = (DexCloseOrderAttachment) transaction.getAttachment(); return isDuplicate(DEX.DEX_CLOSE_ORDER, Long.toUnsignedString(attachment.getContractId()), duplicates, true); } @Override byte getSubtype(); @Override LedgerEvent getLedgerEvent(); @Override AbstractAttachment parseAttachment(ByteBuffer buffer); @Override AbstractAttachment parseAttachment(JSONObject attachmentData); @Override void validateAttachment(Transaction tx); @Override boolean applyAttachmentUnconfirmed(Transaction transaction, Account senderAccount); @Override void applyAttachment(Transaction transaction, Account senderAccount, Account recipientAccount); @Override void undoAttachmentUnconfirmed(Transaction transaction, Account senderAccount); @Override boolean isDuplicate(Transaction transaction, Map<TransactionType, Map<String, Integer>> duplicates); @Override boolean canHaveRecipient(); @Override boolean isPhasingSafe(); @Override String getName(); }### Answer:
@Test void testIsDuplicate() { Transaction tx = mock(Transaction.class); doReturn(attachment).when(tx).getAttachment(); HashMap<TransactionType, Map<String, Integer>> duplicates = new HashMap<>(); assertFalse(transactionType.isDuplicate(tx, duplicates)); assertTrue(transactionType.isDuplicate(tx, duplicates)); assertTrue(transactionType.isDuplicate(tx, duplicates)); } |
### Question:
DexContractTable extends EntityDbTable<ExchangeContract> { public ExchangeContract getById(Long id) { return get(KEY_FACTORY.newKey(id)); } @Inject DexContractTable(); @Override void save(Connection con, ExchangeContract entity); ExchangeContract getById(Long id); List<ExchangeContract> getAllByCounterOrder(Long counterOrderId); List<ExchangeContract> getByOrderIdAndHeight(long orderId, int height); ExchangeContract getLastByOrder(Long orderId); ExchangeContract getLastByCounterOrder(Long orderId); ExchangeContract getByOrderAndCounterOrder(Long orderId, Long counterOrderId); List<ExchangeContract> getOverdueContractsStep1and2(int deadlineToReply); List<ExchangeContract> getOverdueContractsStep1_2_3(int deadlineToReply); }### Answer:
@Test void testInsert() { DbUtils.inTransaction(extension, (con) -> { table.insert(dtd.NEW_EXCHANGE_CONTRACT_16); }); ExchangeContract result = table.getById(dtd.NEW_EXCHANGE_CONTRACT_16.getId()); assertNotNull(result); assertEquals(dtd.NEW_EXCHANGE_CONTRACT_16.getId(), result.getId()); } |
### Question:
EthUtil { public static BigDecimal weiToEther(BigInteger wei) { return Convert.fromWei(wei.toString(), Convert.Unit.ETHER); } private EthUtil(); static EthWalletKey generateNewAccount(); static BigDecimal weiToEther(BigInteger wei); static Long ethToGwei(BigDecimal ether); static BigInteger etherToWei(BigDecimal ether); static BigInteger gweiToWei(Long gwei); static BigDecimal gweiToEth(Long gwei); static BigDecimal atmToEth(Long apl); static Long atmToGwei(Long apl); static Long gweiToAtm(Long gwei); static BigDecimal fromAtm(BigDecimal ix); static boolean isAddressValid(String address); }### Answer:
@Test void weiToEther() { BigDecimal eth = EthUtil.weiToEther(WEI); assertEquals(ETH, eth); } |
### Question:
EthUtil { public static Long ethToGwei(BigDecimal ether) { return Convert.fromWei(etherToWei(ether).toString(), Convert.Unit.GWEI).longValue(); } private EthUtil(); static EthWalletKey generateNewAccount(); static BigDecimal weiToEther(BigInteger wei); static Long ethToGwei(BigDecimal ether); static BigInteger etherToWei(BigDecimal ether); static BigInteger gweiToWei(Long gwei); static BigDecimal gweiToEth(Long gwei); static BigDecimal atmToEth(Long apl); static Long atmToGwei(Long apl); static Long gweiToAtm(Long gwei); static BigDecimal fromAtm(BigDecimal ix); static boolean isAddressValid(String address); }### Answer:
@Test void ethToGwei() { Long gwei = EthUtil.ethToGwei(ETH); assertEquals(GWEI, gwei); } |
### Question:
EthUtil { public static BigInteger etherToWei(BigDecimal ether) { return Convert.toWei(ether, Convert.Unit.ETHER).toBigInteger(); } private EthUtil(); static EthWalletKey generateNewAccount(); static BigDecimal weiToEther(BigInteger wei); static Long ethToGwei(BigDecimal ether); static BigInteger etherToWei(BigDecimal ether); static BigInteger gweiToWei(Long gwei); static BigDecimal gweiToEth(Long gwei); static BigDecimal atmToEth(Long apl); static Long atmToGwei(Long apl); static Long gweiToAtm(Long gwei); static BigDecimal fromAtm(BigDecimal ix); static boolean isAddressValid(String address); }### Answer:
@Test void etherToWei() { BigInteger wei = EthUtil.etherToWei(ETH); assertEquals(WEI, wei); } |
### Question:
EthUtil { public static BigInteger gweiToWei(Long gwei) { return EtherUtil.convert(gwei, EtherUtil.Unit.GWEI); } private EthUtil(); static EthWalletKey generateNewAccount(); static BigDecimal weiToEther(BigInteger wei); static Long ethToGwei(BigDecimal ether); static BigInteger etherToWei(BigDecimal ether); static BigInteger gweiToWei(Long gwei); static BigDecimal gweiToEth(Long gwei); static BigDecimal atmToEth(Long apl); static Long atmToGwei(Long apl); static Long gweiToAtm(Long gwei); static BigDecimal fromAtm(BigDecimal ix); static boolean isAddressValid(String address); }### Answer:
@Test void gweiToWei() { BigInteger wei = EthUtil.gweiToWei(GWEI); assertEquals(WEI, wei); } |
### Question:
EthUtil { public static BigDecimal gweiToEth(Long gwei) { return weiToEther(gweiToWei(gwei)); } private EthUtil(); static EthWalletKey generateNewAccount(); static BigDecimal weiToEther(BigInteger wei); static Long ethToGwei(BigDecimal ether); static BigInteger etherToWei(BigDecimal ether); static BigInteger gweiToWei(Long gwei); static BigDecimal gweiToEth(Long gwei); static BigDecimal atmToEth(Long apl); static Long atmToGwei(Long apl); static Long gweiToAtm(Long gwei); static BigDecimal fromAtm(BigDecimal ix); static boolean isAddressValid(String address); }### Answer:
@Test void gweiToEth() { BigDecimal eth = EthUtil.gweiToEth(GWEI); assertEquals(ETH, eth); } |
### Question:
EthUtil { public static BigDecimal atmToEth(Long apl) { return weiToEther(gweiToWei(atmToGwei(apl))); } private EthUtil(); static EthWalletKey generateNewAccount(); static BigDecimal weiToEther(BigInteger wei); static Long ethToGwei(BigDecimal ether); static BigInteger etherToWei(BigDecimal ether); static BigInteger gweiToWei(Long gwei); static BigDecimal gweiToEth(Long gwei); static BigDecimal atmToEth(Long apl); static Long atmToGwei(Long apl); static Long gweiToAtm(Long gwei); static BigDecimal fromAtm(BigDecimal ix); static boolean isAddressValid(String address); }### Answer:
@Test void atmToEth() { BigDecimal eth = EthUtil.atmToEth(ATM); assertEquals(ETH, eth); } |
### Question:
EthUtil { public static Long gweiToAtm(Long gwei) { return gwei / 10; } private EthUtil(); static EthWalletKey generateNewAccount(); static BigDecimal weiToEther(BigInteger wei); static Long ethToGwei(BigDecimal ether); static BigInteger etherToWei(BigDecimal ether); static BigInteger gweiToWei(Long gwei); static BigDecimal gweiToEth(Long gwei); static BigDecimal atmToEth(Long apl); static Long atmToGwei(Long apl); static Long gweiToAtm(Long gwei); static BigDecimal fromAtm(BigDecimal ix); static boolean isAddressValid(String address); }### Answer:
@Test void gweiToAtm() { Long apl = EthUtil.gweiToAtm(GWEI); assertEquals(ATM, apl); } |
### Question:
FbWalletUtil { public static Integer getWalletFileVersion(Path path) { return getWalletFileVersion(path.toString()); } static Integer getWalletFileVersion(Path path); static Integer getWalletFileVersion(String path); static String getAccount(String path); static ApolloFbWallet buildWallet(byte[] keyStore, String passPhrase); }### Answer:
@Test void getWalletFileVersion() { Integer version1 = FbWalletUtil.getWalletFileVersion(String.join(File.separator, "a2e9b9", "v1_2019-03-19_13-58-16---APL-9ES6-JTW3-JBN4" + "-7LLZQ")); Integer version0 = FbWalletUtil.getWalletFileVersion(String.join(File.separator, "a2e9b9", "v0_2019-03-19_13-58-16---APL-9ES6-JTW3-JBN4-7LLZQ")); assertTrue(Objects.equals(1, version1)); assertTrue(Objects.equals(0, version0)); }
@Test void getWalletFileVersionWhenFileNameNotValid() { Integer version1 = FbWalletUtil.getWalletFileVersion("/Users/user/.apl-blockchain/apl-blockchain-vault-keystore/a2e9b9/vd_2019-03-19_13-58-16---APL-9ES6-JTW3-JBN4-7LLZQ"); Integer version2 = FbWalletUtil.getWalletFileVersion("/Users/user/.apl-blockchain/apl-blockchain-vault-keystore/a2e9b9/1_2019-03-19_13-58-16---APL-9ES6-JTW3-JBN4-7LLZQ"); assertNull(version1); assertNull(version2); } |
### Question:
FbWalletUtil { public static String getAccount(String path) { try { int beginIndex = path.indexOf("---"); if (beginIndex == -1) { return null; } return path.substring(beginIndex + 3); } catch (Exception ex) { LOG.warn(ex.getMessage()); return null; } } static Integer getWalletFileVersion(Path path); static Integer getWalletFileVersion(String path); static String getAccount(String path); static ApolloFbWallet buildWallet(byte[] keyStore, String passPhrase); }### Answer:
@Test void getAccount() { String account1 = FbWalletUtil.getAccount("/Users/user/.apl-blockchain/apl-blockchain-vault-keystore/a2e9b9/v1_2019-03-19_13-58-16---APL-9ES6-JTW3-JBN4-7LLZQ"); String account0 = FbWalletUtil.getAccount("/Users/user/.apl-blockchain/apl-blockchain-vault-keystore/a2e9b9/v0_2019-03-19_13-58-16---APL-9ES6-JTW3-JBN4-7LLZ1"); assertTrue(Objects.equals("APL-9ES6-JTW3-JBN4-7LLZQ", account1)); assertTrue(Objects.equals("APL-9ES6-JTW3-JBN4-7LLZ1", account0)); }
@Test void getAccountWhenFileNameNotValid() { String account = FbWalletUtil.getAccount("v1_2019-03-19_13-58-16-APL-9ES6-JTW3-JBN4-7LLZ"); assertNull(account); } |
### Question:
H2DbInfoExtractor implements DbInfoExtractor { @Override public int getHeight(String dbPath) { JdbcConnectionPool dataSource = createDataSource(dbPath); if (dataSource != null) { int height = getHeight(dataSource); shutdownDb(dataSource); return height; } else return 0; } @Inject H2DbInfoExtractor(@Property("apl.dbUsername") String user,
@Property("apl.dbPassword") String password); @Override int getHeight(String dbPath); @Override Path getPath(String dbPath); }### Answer:
@Test void testGetHeight() { int height = h2DbInfoExtractor.getHeight(path.toString()); Assertions.assertEquals(BlockTestData.BLOCK_13_HEIGHT, height); } |
### Question:
H2DbInfoExtractor implements DbInfoExtractor { @Override public Path getPath(String dbPath) { return createDbPath(dbPath); } @Inject H2DbInfoExtractor(@Property("apl.dbUsername") String user,
@Property("apl.dbPassword") String password); @Override int getHeight(String dbPath); @Override Path getPath(String dbPath); }### Answer:
@Test public void testGetPath() { String path = H2DbInfoExtractorTest.path.toAbsolutePath().toString(); Assertions.assertEquals(Paths.get(path + DbProperties.DB_EXTENSION_WITH_DOT), h2DbInfoExtractor.getPath(path)); } |
### Question:
DbUtils { public static TableData getTableData(Connection connection, String tableName, String schemaName) throws SQLException { Objects.requireNonNull(connection, "Connection cannot be null"); StringValidator.requireNonBlank(tableName, "Table name"); StringValidator.requireNonBlank(schemaName, "Schema"); List<String> columnNames = new ArrayList<>(); List<Integer> columnTypes = new ArrayList<>(); int dbColumn = -1; DatabaseMetaData metaData = connection.getMetaData(); ResultSet rs = metaData.getColumns(null, schemaName.toUpperCase(), tableName.toUpperCase(), null); int index = 0; while (rs.next()) { String columnName = rs.getString("COLUMN_NAME"); int columnType = rs.getInt("DATA_TYPE"); columnNames.add(columnName); columnTypes.add(columnType); if (columnName.equalsIgnoreCase("DB_ID")) { dbColumn = index; } index++; } List<Integer> indexColumns = getIndexColumns(connection, columnNames, columnTypes, schemaName, tableName); return new TableData(dbColumn, tableName, schemaName, columnNames, columnTypes, indexColumns); } static TableData getTableData(Connection connection, String tableName, String schemaName); }### Answer:
@Test public void testGetDbInfoForIndexedTable() throws SQLException { DataSource db = dbExtension.getDatabaseManager().getDataSource(); try (Connection con = db.getConnection()) { TableData result = DbUtils.getTableData(con, "currency", "PUBLIC"); Assertions.assertEquals(CURRENCY_TABLE_DATA, result); } }
@Test public void testGetDbInfoForNonIndexedTable() throws SQLException { DataSource db = dbExtension.getDatabaseManager().getDataSource(); try (Connection con = db.getConnection()) { TableData result = DbUtils.getTableData(con, "two_factor_auth", "PUBLIC"); Assertions.assertEquals(TWO_FACTOR_AUTH_TABLE_DATA, result); } } |
### Question:
DataSourceWrapper implements DataSource { public String getUrl() { return dbUrl; } DataSourceWrapper(DbProperties dbProperties); @Override Connection getConnection(String username, String password); @Override T unwrap(Class<T> iface); @Override boolean isWrapperFor(Class<?> iface); @Override PrintWriter getLogWriter(); @Override void setLogWriter(PrintWriter out); @Override int getLoginTimeout(); @Override void setLoginTimeout(int seconds); @Override java.util.logging.Logger getParentLogger(); HikariPoolMXBean getJmxBean(); Jdbi initWithJdbi(DbVersion dbVersion); void init(DbVersion dbVersion); void update(DbVersion dbVersion); void shutdown(); boolean isShutdown(); void analyzeTables(); @Override Connection getConnection(); String getUrl(); @Override String toString(); }### Answer:
@Test void shouldConstructDataSourceWrapper() { final String dbType = "h2"; final String dbFileName = "2f2b61"; final String dbDir = "/usr/db"; final String user = "usr"; final String pass = "pass"; final String dbParams = "AUTO_SERVER=TRUE;TRACE_LEVEL_FILE=1"; final DbProperties dbProperties = new DbProperties() .dbPassword(pass) .dbUsername(user) .dbDir(dbDir) .dbFileName(dbFileName) .dbParams(dbParams) .dbType(dbType); final DataSourceWrapper dataSourceWrapperActual = new DataSourceWrapper(dbProperties); assertNotNull(dataSourceWrapperActual); final String urlActual = dataSourceWrapperActual.getUrl(); assertNotNull(urlActual); assertEquals( String.format( "jdbc:%s:file:%s/%s;%s", dbType, dbDir, dbFileName, dbParams + ";MV_STORE=TRUE;CACHE_SIZE=" ), urlActual.substring(0, urlActual.lastIndexOf("=") + 1) ); } |
### Question:
OptionDAO { public String get(String optionName) { TransactionalDataSource dataSource = databaseManager.getDataSource(); try (Connection con = dataSource.getConnection()) { PreparedStatement stmt = con.prepareStatement("SELECT * FROM option WHERE name = ?"); stmt.setString(1, optionName); try (ResultSet rs = stmt.executeQuery()) { if (rs.next()) { return rs.getString("value"); } } } catch (SQLException e) { log.error(e.getMessage()); } return null; } @Inject OptionDAO(DatabaseManager databaseManager); String get(String optionName); boolean set(String optionName, String optionValue); boolean delete(String optionName); void deleteAll(); boolean exist(String optionKey); }### Answer:
@Test void get() { String value = optionDAO.get("unknown_key_1"); assertNull(value); } |
### Question:
OptionDAO { public boolean exist(String optionKey) { TransactionalDataSource dataSource = databaseManager.getDataSource(); try (Connection con = dataSource.getConnection()) { PreparedStatement stmt = con.prepareStatement("SELECT count(*) FROM option WHERE name = ?"); stmt.setString(1, optionKey); try (ResultSet rs = stmt.executeQuery()) { if (rs.next()) { return rs.getLong(1) > 0; } } } catch (SQLException e) { log.error(e.getMessage()); } return false; } @Inject OptionDAO(DatabaseManager databaseManager); String get(String optionName); boolean set(String optionName, String optionValue); boolean delete(String optionName); void deleteAll(); boolean exist(String optionKey); }### Answer:
@Test void exist() { boolean exists = optionDAO.exist("unknown_key_1"); assertFalse(exists); exists = optionDAO.exist("existingKey"); assertTrue(exists); exists = optionDAO.exist("existingNullKey"); assertTrue(exists); exists = optionDAO.exist("existingEmptyKey"); assertTrue(exists); } |
### Question:
OptionDAO { public boolean set(String optionName, String optionValue) { TransactionalDataSource dataSource = databaseManager.getDataSource(); if (!exist(optionName)) { try (Connection con = dataSource.getConnection()) { PreparedStatement stmt = con.prepareStatement("INSERT INTO option (name, \"VALUE\") VALUES (?, ?)"); stmt.setString(1, optionName); stmt.setString(2, optionValue); stmt.execute(); } catch (SQLException e) { log.error("OptionDAO insert error, {}={}, {}", optionName, optionValue, e.getMessage()); } } else { try (Connection con = dataSource.getConnection()) { PreparedStatement stmt = con.prepareStatement("UPDATE option set value = ? WHERE name = ?"); stmt.setString(1, optionValue); stmt.setString(2, optionName); stmt.execute(); } catch (SQLException e) { log.error("OptionDAO update error, {}={}, {}", optionName, optionValue, e.getMessage()); } } return true; } @Inject OptionDAO(DatabaseManager databaseManager); String get(String optionName); boolean set(String optionName, String optionValue); boolean delete(String optionName); void deleteAll(); boolean exist(String optionKey); }### Answer:
@Test void set() { String unknown_key = "unknown_key_2"; boolean isInserted = optionDAO.set(unknown_key, "unknown_value"); assertTrue(isInserted); String value = optionDAO.get(unknown_key); assertNotNull(value); assertEquals("unknown_value", value); optionDAO.delete(unknown_key); value = optionDAO.get(unknown_key); assertNull(value); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.