method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
H2WebServerServiceImpl extends AbstractH2ServerService { @Override protected Server createServer(final String [] serverParams) throws DbServerServiceException { try { return Server.createWebServer(serverParams); } catch (final SQLException e) { LOGGER.log(Level.SEVERE, "Failed to create H2 Web Server!", e); throw new DbServerServiceException(e); } } H2WebServerServiceImpl(final String webServerParams); }### Answer:
@Test public void testCreateServer() { String[] params = new String[0]; Server result = service.createServer(params); assertNotNull(result.getPort()); assertEquals("default status", "Not started", result.getStatus()); assertNotNull("default URL", result.getURL()); assertNotNull("default service", result.getService()); }
@Test (expected = DbServerServiceException.class) public void testCreateServerThrowsException() { String[] badParams = new String[]{"-webPort", "ERROR"}; service.createServer(badParams); } |
### Question:
FaultCodeException extends RuntimeException { public MessageResponseStatus getMessageResponseStatus() { return messageResponseStatus; } FaultCodeException(final MessageResponseStatus theMessageResponseStatus,
final String theMessage); FaultCodeException(final MessageResponseStatus theMessageResponseStatus,
final String theMessage,
final Throwable theCause); MessageResponseStatus getMessageResponseStatus(); }### Answer:
@Test public void testGetMessageResponseStatus() { final MessageResponseStatus messageResponseStatus = new TestMessageResponseStatus(); final FaultCodeException faultCodeException = new FaultCodeException(messageResponseStatus, "message"); assertEquals(messageResponseStatus, faultCodeException.getMessageResponseStatus()); } |
### Question:
PortNumberRule implements Rule { @Override public boolean isValid() { if (nullable && port == null) { return true; } return port != null && port > 0 && port <= 65535 ; } PortNumberRule(final Integer thePort, final FaultType errorCode); PortNumberRule(final Integer thePort, final FaultType errorCode, final boolean nullable); @Override boolean isValid(); @Override void validate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testIsValid() { assertTrue(pnrValid.isValid()); assertFalse(pnrNull.isValid()); assertFalse(pnrOne.isValid()); assertFalse(pnrTwo.isValid()); }
@Test public void testInvalidPortNumberWhileNullable() { final PortNumberRule rule = new PortNumberRule(-12, FaultType.INVALID_WEBSERVER_PORT, true); assertFalse(rule.isValid()); } |
### Question:
PortNumberRule implements Rule { @Override public void validate() throws BadRequestException { if (!isValid()) { throw new BadRequestException(getMessageResponseStatus(), getMessage()); } } PortNumberRule(final Integer thePort, final FaultType errorCode); PortNumberRule(final Integer thePort, final FaultType errorCode, final boolean nullable); @Override boolean isValid(); @Override void validate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testValidate() { pnrValid.validate(); }
@Test(expected = BadRequestException.class) public void testValidateNotValid() { pnrNull.validate(); } |
### Question:
PortNumberRule implements Rule { protected MessageResponseStatus getMessageResponseStatus() { return error; } PortNumberRule(final Integer thePort, final FaultType errorCode); PortNumberRule(final Integer thePort, final FaultType errorCode, final boolean nullable); @Override boolean isValid(); @Override void validate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGetMessageResponseStatus() { assertEquals("InvalidWebServerPortNumber", pnrOne.getMessageResponseStatus().getMessage()); } |
### Question:
PortNumberRule implements Rule { protected String getMessage() { return "Port specified is invalid" + (port != null ? " (" + port + ")." : "."); } PortNumberRule(final Integer thePort, final FaultType errorCode); PortNumberRule(final Integer thePort, final FaultType errorCode, final boolean nullable); @Override boolean isValid(); @Override void validate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGetMessage() { assertEquals("Port specified is invalid.", pnrNull.getMessage()); assertEquals("Port specified is invalid (0).", pnrOne.getMessage()); } |
### Question:
HostNameRule extends ValidNameRule { @Override public MessageResponseStatus getMessageResponseStatus() { return FaultType.INVALID_HOST_NAME; } HostNameRule(final String theName); @Override MessageResponseStatus getMessageResponseStatus(); @Override String getMessage(); @Override boolean isValid(); }### Answer:
@Test public void testGetMessageResponseStatus() { assertEquals("InvalidHostName", hnrOne.getMessageResponseStatus().getMessage()); } |
### Question:
HostNameRule extends ValidNameRule { @Override public String getMessage() { return "Invalid Host Name : \"" + name + "\""; } HostNameRule(final String theName); @Override MessageResponseStatus getMessageResponseStatus(); @Override String getMessage(); @Override boolean isValid(); }### Answer:
@Test public void testGetMessage() { assertEquals("Invalid Host Name : \"Name\"", hnrOne.getMessage()); } |
### Question:
JvmNameRule extends ValidNameRule { @Override public boolean isValid() { return super.isValid() && name.length() <= MAX_LENGTH; } JvmNameRule(final String theName); @Override boolean isValid(); final int MAX_LENGTH; }### Answer:
@Test public void testValidNames() { final String[] validNames = {"abc", "def", "_-", "123j .", "64MycharacterNameIsValidNameShouldPassTest1234567891011213141516"}; for (final String name : validNames) { final JvmNameRule rule = new JvmNameRule(name); assertTrue(rule.isValid()); rule.validate(); } }
@Test public void testInvalidNames() { final String[] invalidNames = {"", " ", null, "65charactersNameHereCheckforInvalidity123456789101112131415161718"}; for (final String name : invalidNames) { final JvmNameRule rule = new JvmNameRule(name); assertFalse(rule.isValid()); try { rule.validate(); } catch (final BadRequestException bre) { assertTrue(true); } } } |
### Question:
GroupNameRule extends ValidNameRule { @Override protected MessageResponseStatus getMessageResponseStatus() { return FaultType.INVALID_GROUP_NAME; } GroupNameRule(final String theName); @Override void validate(); }### Answer:
@Test public void testGetMessageResponseStatus() { final MessageResponseStatus messageResponseStatus = rule.getMessageResponseStatus(); assertEquals("InvalidGroupName", messageResponseStatus.getMessage()); } |
### Question:
GroupNameRule extends ValidNameRule { @Override protected String getMessage() { return "Invalid Group Name: \"" + name + "\""; } GroupNameRule(final String theName); @Override void validate(); }### Answer:
@Test public void testGetMessage() { final String message = rule.getMessage(); assertEquals("Invalid Group Name: \"\"", message); } |
### Question:
GroupNameRule extends ValidNameRule { @Override public void validate() throws BadRequestException { if (!isValid()) { throw new BadRequestException(getMessageResponseStatus(), getMessage()); } } GroupNameRule(final String theName); @Override void validate(); }### Answer:
@Test public void testValidNames() { final String[] validNames = {"abc", "def", "123","group123","group_123."}; for (final String name : validNames) { final GroupNameRule rule = new GroupNameRule(name); assertTrue(rule.isValid()); rule.validate(); } }
@Test public void testInvalidNames() { final String[] invalidNames = {"", " ", null}; for (final String name : invalidNames) { final GroupNameRule rule = new GroupNameRule(name); assertFalse(rule.isValid()); try { rule.validate(); } catch (final BadRequestException bre) { assertTrue(true); } } } |
### Question:
GroupIdsRule extends MultipleIdentifiersRule<Group> implements Rule { @Override protected Rule createRule(final Identifier<Group> anId) { return new GroupIdRule(anId); } GroupIdsRule(final Collection<Identifier<Group>> theGroupIds); GroupIdsRule(final Set<Identifier<Group>> theGroupIds); }### Answer:
@Test public void testCreateRuleIdentifierOfGroup() { final Set<Identifier<Group>> groupIds = new TreeSet<Identifier<Group>>(); final GroupIdsRule gir = new GroupIdsRule(groupIds); final Long id = new Long(0); final Identifier<Group> anId = new Identifier<Group>(id); final Rule rule = gir.createRule(anId); assertTrue(rule.isValid()); } |
### Question:
CommandOutput implements Serializable { public void cleanStandardOutput() { standardOutput = standardOutput.replaceAll("\u001B\\[[;\\d]*m", "") .replaceAll("\u001B\\]0;~", "") .replaceAll("\\n", "NEWLINE") .replaceAll("\\p{C}", "") .replaceAll("NEWLINE", "\\\n"); } CommandOutput(final ExecReturnCode theReturnCode,
final String theStandardOutput,
final String theStandardError); ExecReturnCode getReturnCode(); String getStandardOutput(); String getStandardError(); String standardErrorOrStandardOut(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); void cleanStandardOutput(); String extractMessageFromStandardOutput(); void cleanHeapDumpStandardOutput(); }### Answer:
@Test public void testCleanStandardOutput(){ CommandOutput testObject = new CommandOutput(new ExecReturnCode(0), STANDARD_OUTPUT_WITH_SPECIAL_CHARS,""); testObject.cleanStandardOutput(); assertEquals(STANDARD_OUTPUT_WITH_SPECIAL_CHARS_REMOVED, testObject.getStandardOutput()); } |
### Question:
CommandOutput implements Serializable { @Override public int hashCode() { return new HashCodeBuilder() .append(returnCode) .append(standardOutput) .append(standardError) .toHashCode(); } CommandOutput(final ExecReturnCode theReturnCode,
final String theStandardOutput,
final String theStandardError); ExecReturnCode getReturnCode(); String getStandardOutput(); String getStandardError(); String standardErrorOrStandardOut(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); void cleanStandardOutput(); String extractMessageFromStandardOutput(); void cleanHeapDumpStandardOutput(); }### Answer:
@Test public void testCommandOutputHashcode(){ CommandOutput testObject1 = new CommandOutput(new ExecReturnCode(0), STANDARD_OUTPUT_WITH_SPECIAL_CHARS,""); CommandOutput testObject2 = new CommandOutput(new ExecReturnCode(0), STANDARD_OUTPUT_WITH_SPECIAL_CHARS,""); assertEquals(testObject1.hashCode(), testObject2.hashCode()); } |
### Question:
CommandOutput implements Serializable { public String extractMessageFromStandardOutput() { return standardOutput.replaceAll("\\n", "NEWLINE") .replaceAll("^.*?NEWLINE\\$", "") .replaceAll("^.*\\s\\\".*\\\"\\s\\d+\\sNEWLINE", "") .replaceAll("[A-Za-z0-9]+@[A-Za-z0-9]+\\s~NEWLINE\\$", "") .replaceAll("\\s\\sexitNEWLINElogout", "") .replaceAll("NEWLINE", "\\\n"); } CommandOutput(final ExecReturnCode theReturnCode,
final String theStandardOutput,
final String theStandardError); ExecReturnCode getReturnCode(); String getStandardOutput(); String getStandardError(); String standardErrorOrStandardOut(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); void cleanStandardOutput(); String extractMessageFromStandardOutput(); void cleanHeapDumpStandardOutput(); }### Answer:
@Test public void testExtractMessageFromStandardOutput(){ CommandOutput testObject = new CommandOutput(new ExecReturnCode(36), STANDARD_OUTPUT_WITH_SHELL_INFO,""); testObject.cleanStandardOutput(); assertEquals(STANDARD_OUTPUT_WITH_SHELL_INFO_REMOVED, testObject.extractMessageFromStandardOutput()); } |
### Question:
ExecCommand implements Serializable { public List<String> getCommandFragments() { return commandFragments; } ExecCommand(final String... theCommandFragments); ExecCommand(final List<String> theCommandFragments); ExecCommand(final List<String> theCommandFragmentsReplace, final List<String> theCommandFragmentsNotReplace); List<String> getCommandFragments(); String toCommandString(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); boolean getRunInShell(); }### Answer:
@Test public void testExecCommandDual(){ List<String> formatStrings = Arrays.asList("abc\\aaa", "12345\\"); List<String> unformatStrings = Arrays.asList("xyz\\bbb", "67890\\"); List<String> result = new ExecCommand(formatStrings, unformatStrings).getCommandFragments(); List<String> expected = Arrays.asList("abc/aaa", "12345/", "xyz\\bbb", "67890\\"); assertEquals(result, expected); } |
### Question:
FileUtility { public Set<String> getZipRootDirs(final String zipFilename) { final Set<String> zipRootDirs = new HashSet<>(); try { if (zipFilename.indexOf(TAR_GZIP_FILE_EXT) > 0) { return getGZipRootDirs(zipFilename); } final ZipFile zipFile = new ZipFile(zipFilename); final Enumeration zipEntryEnumeration = zipFile.entries(); while (zipEntryEnumeration.hasMoreElements()) { final String zipEntry = zipEntryEnumeration.nextElement().toString(); final int slashIdx = zipEntry.indexOf('/'); if (slashIdx > 0) { zipRootDirs.add(zipEntry.substring(0, slashIdx)); } } zipFile.close(); return zipRootDirs; } catch (final IOException e) { throw new FileUtilityException(MessageFormat.format("Failed to get {0} parent path!", zipFilename), e); } } void unzip(final File zipFile, final File destination); Set<String> getZipRootDirs(final String zipFilename); void createJarArchive(File archiveFile, File[] filesToBeJared, String parent); static Set<String> getGZipRootDirs(String tarGzipFile); static String getCheckSum(final String fileAbsolutePath); }### Answer:
@Test public void testGetZipDirRoots() { Set<String> dirs = fileUtility.getZipRootDirs(SRC_TEST_RESOURCES + "instance-template-7.0.55.zip"); LOGGER.info("Size {}", dirs.size()); assertEquals(dirs.size(), 7); } |
### Question:
WebServer implements Serializable { public Identifier<WebServer> getId() { return id; } WebServer(final Identifier<WebServer> theId,
final Collection<Group> theGroups,
final String theName); WebServer(final Identifier<WebServer> theId,
final Collection<Group> theGroups,
final String theName,
final String theHost,
final Integer thePort,
final Integer theHttpsPort,
final Path theStatusPath,
final WebServerReachableState state,
final Media apacheHttpdMedia); WebServer(final Identifier<WebServer> id,
final String host,
final String name,
final Integer port,
final Integer httpsPort,
final Path statusPath,
final WebServerReachableState state,
final Media apacheHttpdMedia); Identifier<WebServer> getId(); String getName(); String getHost(); Integer getPort(); Integer getHttpsPort(); Collection<Group> getGroups(); Collection<Identifier<Group>> getGroupIds(); Path getStatusPath(); URI getStatusUri(); WebServerReachableState getState(); String getStateLabel(); Media getApacheHttpdMedia(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGetId() { assertEquals(wsId, ws.getId()); } |
### Question:
WebServer implements Serializable { public String getName() { return name; } WebServer(final Identifier<WebServer> theId,
final Collection<Group> theGroups,
final String theName); WebServer(final Identifier<WebServer> theId,
final Collection<Group> theGroups,
final String theName,
final String theHost,
final Integer thePort,
final Integer theHttpsPort,
final Path theStatusPath,
final WebServerReachableState state,
final Media apacheHttpdMedia); WebServer(final Identifier<WebServer> id,
final String host,
final String name,
final Integer port,
final Integer httpsPort,
final Path statusPath,
final WebServerReachableState state,
final Media apacheHttpdMedia); Identifier<WebServer> getId(); String getName(); String getHost(); Integer getPort(); Integer getHttpsPort(); Collection<Group> getGroups(); Collection<Identifier<Group>> getGroupIds(); Path getStatusPath(); URI getStatusUri(); WebServerReachableState getState(); String getStateLabel(); Media getApacheHttpdMedia(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGetName() { assertEquals(NAME, ws.getName()); } |
### Question:
WebServer implements Serializable { public String getHost() { return host; } WebServer(final Identifier<WebServer> theId,
final Collection<Group> theGroups,
final String theName); WebServer(final Identifier<WebServer> theId,
final Collection<Group> theGroups,
final String theName,
final String theHost,
final Integer thePort,
final Integer theHttpsPort,
final Path theStatusPath,
final WebServerReachableState state,
final Media apacheHttpdMedia); WebServer(final Identifier<WebServer> id,
final String host,
final String name,
final Integer port,
final Integer httpsPort,
final Path statusPath,
final WebServerReachableState state,
final Media apacheHttpdMedia); Identifier<WebServer> getId(); String getName(); String getHost(); Integer getPort(); Integer getHttpsPort(); Collection<Group> getGroups(); Collection<Identifier<Group>> getGroupIds(); Path getStatusPath(); URI getStatusUri(); WebServerReachableState getState(); String getStateLabel(); Media getApacheHttpdMedia(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGetHost() { assertEquals(HOST, ws.getHost()); } |
### Question:
WebServer implements Serializable { public Integer getPort() { return port; } WebServer(final Identifier<WebServer> theId,
final Collection<Group> theGroups,
final String theName); WebServer(final Identifier<WebServer> theId,
final Collection<Group> theGroups,
final String theName,
final String theHost,
final Integer thePort,
final Integer theHttpsPort,
final Path theStatusPath,
final WebServerReachableState state,
final Media apacheHttpdMedia); WebServer(final Identifier<WebServer> id,
final String host,
final String name,
final Integer port,
final Integer httpsPort,
final Path statusPath,
final WebServerReachableState state,
final Media apacheHttpdMedia); Identifier<WebServer> getId(); String getName(); String getHost(); Integer getPort(); Integer getHttpsPort(); Collection<Group> getGroups(); Collection<Identifier<Group>> getGroupIds(); Path getStatusPath(); URI getStatusUri(); WebServerReachableState getState(); String getStateLabel(); Media getApacheHttpdMedia(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGetPort() { assertEquals(port, ws.getPort()); } |
### Question:
BinaryDistributionLockManagerImpl implements BinaryDistributionLockManager { @Override public void writeLock(String resourceName) { synchronized(lockObject) { if (!binariesWriteLocks.containsKey(resourceName)) { binariesWriteLocks.put(resourceName, new ReentrantReadWriteLock()); } } binariesWriteLocks.get(resourceName).writeLock().lock(); LOGGER.info("Added write lock for resource {}", resourceName); } @Override void writeLock(String resourceName); @Override void writeUnlock(String resourceName); }### Answer:
@Test public void writeLock() throws Exception { binaryDistributionLockManager.writeLock("TEST-JVM"); binaryDistributionLockManager.writeUnlock("TEST-JVM"); } |
### Question:
WebServer implements Serializable { public Collection<Group> getGroups() { return groups.values(); } WebServer(final Identifier<WebServer> theId,
final Collection<Group> theGroups,
final String theName); WebServer(final Identifier<WebServer> theId,
final Collection<Group> theGroups,
final String theName,
final String theHost,
final Integer thePort,
final Integer theHttpsPort,
final Path theStatusPath,
final WebServerReachableState state,
final Media apacheHttpdMedia); WebServer(final Identifier<WebServer> id,
final String host,
final String name,
final Integer port,
final Integer httpsPort,
final Path statusPath,
final WebServerReachableState state,
final Media apacheHttpdMedia); Identifier<WebServer> getId(); String getName(); String getHost(); Integer getPort(); Integer getHttpsPort(); Collection<Group> getGroups(); Collection<Identifier<Group>> getGroupIds(); Path getStatusPath(); URI getStatusUri(); WebServerReachableState getState(); String getStateLabel(); Media getApacheHttpdMedia(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGetGroups() { assertEquals(0, ws.getGroups().size()); } |
### Question:
WebServer implements Serializable { public Collection<Identifier<Group>> getGroupIds() { return groups.keySet(); } WebServer(final Identifier<WebServer> theId,
final Collection<Group> theGroups,
final String theName); WebServer(final Identifier<WebServer> theId,
final Collection<Group> theGroups,
final String theName,
final String theHost,
final Integer thePort,
final Integer theHttpsPort,
final Path theStatusPath,
final WebServerReachableState state,
final Media apacheHttpdMedia); WebServer(final Identifier<WebServer> id,
final String host,
final String name,
final Integer port,
final Integer httpsPort,
final Path statusPath,
final WebServerReachableState state,
final Media apacheHttpdMedia); Identifier<WebServer> getId(); String getName(); String getHost(); Integer getPort(); Integer getHttpsPort(); Collection<Group> getGroups(); Collection<Identifier<Group>> getGroupIds(); Path getStatusPath(); URI getStatusUri(); WebServerReachableState getState(); String getStateLabel(); Media getApacheHttpdMedia(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGetGroupIds() { assertEquals(0, ws.getGroupIds().size()); } |
### Question:
ResourceIdentifier { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || ResourceIdentifier.class != o.getClass()) return false; ResourceIdentifier that = (ResourceIdentifier) o; return new EqualsBuilder() .append(resourceName, that.resourceName) .append(groupName, that.groupName) .append(webServerName, that.webServerName) .append(jvmName, that.jvmName) .append(webAppName, that.webAppName) .isEquals(); } private ResourceIdentifier(final Builder builder); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); final String resourceName; final String groupName; final String webServerName; final String jvmName; final String webAppName; }### Answer:
@Test public void testIsEqualsSucceed() { ResourceIdentifier resourceIdentifier = new ResourceIdentifier. Builder(). setGroupName("a group"). setJvmName("a jvm"). build(); ResourceIdentifier anotherResourceIdentifier = new ResourceIdentifier. Builder(). setGroupName("a group"). setJvmName("a jvm"). build(); assertTrue(resourceIdentifier.equals(anotherResourceIdentifier)); }
@Test public void testIsEqualsFail() { ResourceIdentifier resourceIdentifier = new ResourceIdentifier. Builder(). setGroupName("a group"). setJvmName("a jvm"). build(); ResourceIdentifier anotherResourceIdentifier = new ResourceIdentifier. Builder(). setGroupName("another group"). setJvmName("another jvm"). build(); assertTrue(!resourceIdentifier.equals(anotherResourceIdentifier)); } |
### Question:
DecryptPassword { public String decrypt(char[] encyptedValue) { return decrypt(String.valueOf(encyptedValue)); } DecryptPassword(); DecryptPassword(String encryptImpl, String decryptImpl); String decrypt(char[] encyptedValue); String decrypt(String encryptedValue); String encrypt(String unencryptedValue); }### Answer:
@Test public void testDecrypt() { String dummyPassword = "abcd"; assertEquals("DECRYPT:abcd", new DecryptPassword(encryptor, decryptor).decrypt(dummyPassword)); } |
### Question:
DecryptPassword { public String encrypt(String unencryptedValue) { if (unencryptedValue==null) { return null; } final ExpressionParser expressionParser = new SpelExpressionParser(); final Expression encryptExpression = expressionParser.parseExpression(encryptorImpl); final StandardEvaluationContext context = new StandardEvaluationContext(); context.setVariable("stringToEncrypt", unencryptedValue); return encryptExpression.getValue(context, String.class); } DecryptPassword(); DecryptPassword(String encryptImpl, String decryptImpl); String decrypt(char[] encyptedValue); String decrypt(String encryptedValue); String encrypt(String unencryptedValue); }### Answer:
@Test public void testEncrypt() { String dummyPassword = "abcd"; assertEquals("ENCRYPT:abcd", new DecryptPassword(encryptor, decryptor).encrypt(dummyPassword)); } |
### Question:
JvmWinSvcAcctPasswordScrubberServiceImpl implements ScrubberService { @Override public String scrub(final String raw) { for (final String password : objectStoreService.getIterable()) { final String scrubbedStr = raw.replaceAll(decryptor.decrypt(password), REPLACEMENT); if (!raw.equalsIgnoreCase(scrubbedStr)) { return scrubbedStr; } } return raw; } JvmWinSvcAcctPasswordScrubberServiceImpl(final ObjectStoreService<String> objectStoreService,
final DecryptPassword decryptor); @Override String scrub(final String raw); }### Answer:
@Test public void testScrubRawStr1() { when(mockDecryptPassword.decrypt("secret")).thenReturn("secret"); final String result = jvmWinSvcAcctPasswordScrubberService.scrub(TEST_RAW_STR_1); assertEquals(SCRUBBED_STR_1, result); }
@Test public void testScrubRawStr2() { when(mockDecryptPassword.decrypt("secret")).thenReturn("secret"); final String result = jvmWinSvcAcctPasswordScrubberService.scrub(TEST_RAW_STR_2); assertEquals(SCRUBBED_STR_2, result); } |
### Question:
JGroupsMessagingServiceImpl implements MessagingService<Message> { @Override public void init() { try { LOGGER.info("JGroups channel connecting..."); connect(clusterName); } catch (final Exception e) { throw new MessagingServiceException("Failed to initialize the service!", e); } } JGroupsMessagingServiceImpl(final JChannel channel, final String clusterName); @Override void init(); @Override void send(final Message msg); @Override void destroy(); JChannel getChannel(); @Override String toString(); }### Answer:
@Test public void testInit() throws Exception { when(mockChannel.isConnected()).thenReturn(false); messagingService.init(); verify(mockChannel).connect(eq("testCluster")); }
@Test(expected = MessagingServiceException.class) @SuppressWarnings("unchecked") public void testInitWithErrors() throws Exception { when(mockChannel.isConnected()).thenThrow(Exception.class); messagingService.init(); } |
### Question:
JGroupsMessagingServiceImpl implements MessagingService<Message> { @Override public void send(final Message msg) { try { connect(clusterName); LOGGER.info("Sending msg {}", msg); LOGGER.info("Msg content = {}", msg.getObject()); channel.send(msg); } catch (final Exception e) { LOGGER.error(e.getMessage(), e); throw new MessagingServiceException("Failed to deliver message!", e); } } JGroupsMessagingServiceImpl(final JChannel channel, final String clusterName); @Override void init(); @Override void send(final Message msg); @Override void destroy(); JChannel getChannel(); @Override String toString(); }### Answer:
@Test public void testSend() throws Exception { final Message msg = new Message(); messagingService.send(msg); verify(mockChannel).send(eq(msg)); }
@Test(expected = MessagingServiceException.class) public void testSendWithErrors() throws Exception { final Message msg = new Message(); doThrow(Exception.class).when(mockChannel).send(msg); messagingService.send(msg); } |
### Question:
JGroupsMessagingServiceImpl implements MessagingService<Message> { @Override public void destroy() { if (channel.isConnected()) { LOGGER.info("Closing channel connection..."); channel.close(); LOGGER.info("Channel closed"); } } JGroupsMessagingServiceImpl(final JChannel channel, final String clusterName); @Override void init(); @Override void send(final Message msg); @Override void destroy(); JChannel getChannel(); @Override String toString(); }### Answer:
@Test public void testDestroy() throws Exception { when(mockChannel.isConnected()).thenReturn(true); messagingService.destroy(); verify(mockChannel).close(); }
@Test public void testDestroyChannelAlreadyDisconnected() throws Exception { when(mockChannel.isConnected()).thenReturn(false); messagingService.destroy(); verify(mockChannel, never()).close(); } |
### Question:
JGroupsMessagingServiceImpl implements MessagingService<Message> { public JChannel getChannel() { return channel; } JGroupsMessagingServiceImpl(final JChannel channel, final String clusterName); @Override void init(); @Override void send(final Message msg); @Override void destroy(); JChannel getChannel(); @Override String toString(); }### Answer:
@Test public void testGetChannel() { assertEquals(mockChannel, messagingService.getChannel()); } |
### Question:
MediaDaoImpl extends AbstractCrudServiceImpl<JpaMedia> implements MediaDao { @Override public JpaMedia find(final String name) { final Query q = entityManager.createNamedQuery(JpaMedia.QUERY_FIND_BY_NAME, JpaMedia.class); q.setParameter(JpaMedia.PARAM_NAME, name); return (JpaMedia) q.getSingleResult(); } @Override JpaMedia find(final String name); @Override JpaMedia findByNameAndType(String name, MediaType type); }### Answer:
@Test public void testCrud() { final JpaMedia media = new JpaMedia(); media.setName("jdk 1.8"); media.setType(MediaType.JDK); media.setLocalPath(Paths.get("c:/java/jdk.zip")); media.setRemoteDir(Paths.get("c:/ctp")); media.setRootDir(Paths.get("jdk-1.8")); mediaDao.create(media); final JpaMedia foundMedia = mediaDao.find("jdk 1.8"); assertEquals(media, foundMedia); assertEquals(mediaDao.findAll().size(), 1); mediaDao.remove(media); assertEquals(mediaDao.findAll().size(), 0); } |
### Question:
WebServerResourceHandler extends ResourceHandler { @Override public String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData) { if (canHandle(resourceIdentifier)) { return webServerPersistenceService.updateResourceMetaData(resourceIdentifier.webServerName, resourceName, metaData); } else { return successor.updateResourceMetaData(resourceIdentifier, resourceName, metaData); } } WebServerResourceHandler(final ResourceDao resourceDao,
final WebServerPersistenceService webServerPersistenceService,
final ResourceContentGeneratorService resourceContentGeneratorService,
final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testUpdateMetaData() { final String updatedMetaData = "{\"updated\":\"meta-data\"}"; final String resourceName = "update-my-meta-data.txt"; when(mockWebServerPersistence.updateResourceMetaData(anyString(), anyString(), anyString())).thenReturn(updatedMetaData); webServerResourceHandler.updateResourceMetaData(resourceIdentifier, resourceName, updatedMetaData); verify(mockWebServerPersistence).updateResourceMetaData(eq(resourceIdentifier.webServerName), eq(resourceName), eq(updatedMetaData)); }
@Test public void testUpdateMetaDataCallsSuccessor() { final String updatedMetaData = "{\"updated\":\"meta-data\"}"; final String resourceName = "update-my-meta-data.txt"; ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName(resourceName).setGroupName("not-a-webserver").build(); webServerResourceHandler.updateResourceMetaData(notMeResourceIdentifier, resourceName, updatedMetaData); verify(mockSuccessor).updateResourceMetaData(eq(notMeResourceIdentifier), eq(resourceName), eq(updatedMetaData)); } |
### Question:
WebServerResourceHandler extends ResourceHandler { @Override public Object getSelectedValue(ResourceIdentifier resourceIdentifier) { if (canHandle(resourceIdentifier)){ return webServerPersistenceService.findWebServerByName(resourceIdentifier.webServerName); } else { return successor.getSelectedValue(resourceIdentifier); } } WebServerResourceHandler(final ResourceDao resourceDao,
final WebServerPersistenceService webServerPersistenceService,
final ResourceContentGeneratorService resourceContentGeneratorService,
final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testGetSelectedValue() { WebServer mockWebServer = mock(WebServer.class); when(mockWebServerPersistence.findWebServerByName(anyString())).thenReturn(mockWebServer); WebServer webServer = (WebServer) webServerResourceHandler.getSelectedValue(resourceIdentifier); assertEquals(mockWebServer, webServer); }
@Test public void testGetSelectedValueCallsSuccessor() { ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName("webserver-resource").setGroupName("not-a-webserver").build(); webServerResourceHandler.getSelectedValue(notMeResourceIdentifier); verify(mockSuccessor).getSelectedValue(notMeResourceIdentifier); } |
### Question:
WebServerResourceHandler extends ResourceHandler { @Override public List<String> getResourceNames(ResourceIdentifier resourceIdentifier) { if (canHandle(resourceIdentifier)){ return webServerPersistenceService.getResourceTemplateNames(resourceIdentifier.webServerName); } else { return successor.getResourceNames(resourceIdentifier); } } WebServerResourceHandler(final ResourceDao resourceDao,
final WebServerPersistenceService webServerPersistenceService,
final ResourceContentGeneratorService resourceContentGeneratorService,
final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testGetResourceNames() { webServerResourceHandler.getResourceNames(resourceIdentifier); verify(mockWebServerPersistence).getResourceTemplateNames(anyString()); ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName("what-webserver").setGroupName("not-a-web-server").build(); webServerResourceHandler.getResourceNames(notMeResourceIdentifier); verify(mockSuccessor).getResourceNames(notMeResourceIdentifier); } |
### Question:
GroupLevelAppResourceHandler extends ResourceHandler { @Override public Object getSelectedValue(ResourceIdentifier resourceIdentifier) { if (canHandle(resourceIdentifier)) { return applicationPersistenceService.getApplication(resourceIdentifier.webAppName); } else { return successor.getSelectedValue(resourceIdentifier); } } GroupLevelAppResourceHandler(final ResourceDao resourceDao,
final GroupPersistenceService groupPersistenceService,
final JvmPersistenceService jvmPersistenceService,
final ApplicationPersistenceService applicationPersistenceService,
final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(final ResourceIdentifier resourceIdentifier, final String resourceName, final String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testGetSelectedValue() { Object selectedValue = groupAppResourceHandler.getSelectedValue(resourceIdentifier); assertNull(selectedValue); }
@Test public void testGetSelectedValueCallsSuccessor() { ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName("whats-app-amiright").setGroupName("not-a-web-app").build(); groupAppResourceHandler.getSelectedValue(notMeResourceIdentifier); verify(mockSuccessor).getSelectedValue(notMeResourceIdentifier); } |
### Question:
GroupLevelAppResourceHandler extends ResourceHandler { @Override public List<String> getResourceNames(ResourceIdentifier resourceIdentifier) { if (canHandle(resourceIdentifier)) { return resourceDao.getGroupLevelAppResourceNames(resourceIdentifier.groupName, resourceIdentifier.webAppName); } else { return successor.getResourceNames(resourceIdentifier); } } GroupLevelAppResourceHandler(final ResourceDao resourceDao,
final GroupPersistenceService groupPersistenceService,
final JvmPersistenceService jvmPersistenceService,
final ApplicationPersistenceService applicationPersistenceService,
final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(final ResourceIdentifier resourceIdentifier, final String resourceName, final String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testGetResourceNames() { groupAppResourceHandler.getResourceNames(resourceIdentifier); verify(mockResourceDao).getGroupLevelAppResourceNames(eq(resourceIdentifier.groupName), eq(resourceIdentifier.webAppName)); ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName("whats-app-amiright").setGroupName("not-a-web-app").build(); groupAppResourceHandler.getResourceNames(notMeResourceIdentifier); verify(mockSuccessor).getResourceNames(notMeResourceIdentifier); } |
### Question:
AppResourceHandler extends ResourceHandler { @Override public Object getSelectedValue(ResourceIdentifier resourceIdentifier) { if (canHandle(resourceIdentifier)) { Application application = applicationPersistenceService.getApplication(resourceIdentifier.webAppName); application.setParentJvm(jvmPersistenceService.findJvmByExactName(resourceIdentifier.jvmName)); return application; } else { return successor.getSelectedValue(resourceIdentifier); } } AppResourceHandler(final ResourceDao resourceDao, final JvmPersistenceService jvmPersistenceService,
final ApplicationPersistenceService applicationPersistenceService,
final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testGetSelectedValue() { Application mockApp = mock(Application.class); Jvm mockJvm = mock(Jvm.class); when(mockAppPersistence.getApplication(anyString())).thenReturn(mockApp); when(mockJvmPersistence.findJvmByExactName(anyString())).thenReturn(mockJvm); Application app = (Application) appResourceHandler.getSelectedValue(resourceIdentifier); verify(mockApp).setParentJvm(eq(mockJvm)); assertEquals(mockApp, app); }
@Test public void testGetSelectedValueCallsSuccessor() { ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName("whats-app-amiright").setGroupName("not-a-web-app").build(); Application app = (Application) appResourceHandler.getSelectedValue(notMeResourceIdentifier); verify(mockSuccessor).getSelectedValue(notMeResourceIdentifier); } |
### Question:
AppResourceHandler extends ResourceHandler { @Override public List<String> getResourceNames(ResourceIdentifier resourceIdentifier) { if (canHandle(resourceIdentifier)) { return applicationPersistenceService.getResourceTemplateNames(resourceIdentifier.webAppName, resourceIdentifier.jvmName); } else { return successor.getResourceNames(resourceIdentifier); } } AppResourceHandler(final ResourceDao resourceDao, final JvmPersistenceService jvmPersistenceService,
final ApplicationPersistenceService applicationPersistenceService,
final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testGetResourceNames() { appResourceHandler.getResourceNames(resourceIdentifier); verify(mockAppPersistence).getResourceTemplateNames(anyString(), anyString()); ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName("whats-app-amiright").setGroupName("not-a-web-app").build(); appResourceHandler.getResourceNames(notMeResourceIdentifier); verify(mockSuccessor).getResourceNames(notMeResourceIdentifier); } |
### Question:
ExternalPropertiesResourceHandler extends ResourceHandler { @Override protected boolean canHandle(ResourceIdentifier resourceIdentifier) { return StringUtils.isNotEmpty(resourceIdentifier.resourceName) && StringUtils.isEmpty(resourceIdentifier.webAppName) && StringUtils.isEmpty(resourceIdentifier.jvmName) && StringUtils.isEmpty(resourceIdentifier.groupName) && StringUtils.isEmpty(resourceIdentifier.webServerName); } ExternalPropertiesResourceHandler(final ResourceDao resourceDao, final ResourceHandler successor); @Override ConfigTemplate fetchResource(ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testCanHandle() { ResourceIdentifier.Builder resourceIdentifier = new ResourceIdentifier.Builder(); resourceIdentifier.setGroupName(null); resourceIdentifier.setWebAppName(null); resourceIdentifier.setJvmName(null); resourceIdentifier.setWebServerName(null); resourceIdentifier.setResourceName("external.properties"); assertTrue(externalPropertiesResourceHandler.canHandle(resourceIdentifier.build())); } |
### Question:
ExternalPropertiesResourceHandler extends ResourceHandler { @Override public void deleteResource(ResourceIdentifier resourceIdentifier) { throw new UnsupportedOperationException(); } ExternalPropertiesResourceHandler(final ResourceDao resourceDao, final ResourceHandler successor); @Override ConfigTemplate fetchResource(ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test (expected = UnsupportedOperationException.class) public void testDeleteExternalProperties() { ResourceIdentifier.Builder resourceIdentifier = new ResourceIdentifier.Builder(); externalPropertiesResourceHandler.deleteResource(resourceIdentifier.build()); } |
### Question:
JvmResourceHandler extends ResourceHandler { @Override public String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData) { if (canHandle(resourceIdentifier)) { return jvmPersistenceService.updateResourceMetaData(resourceIdentifier.jvmName, resourceName, metaData); } else { return successor.updateResourceMetaData(resourceIdentifier, resourceName, metaData); } } JvmResourceHandler(final ResourceDao resourceDao, final GroupPersistenceService groupPersistenceService,
final JvmPersistenceService jvmPersistenceService, final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testUpdateMetaData() { final String updatedMetaData = "{\"updated\":\"meta-data\"}"; final String resourceName = "update-my-meta-data.txt"; when(mockJvmPersistence.updateResourceMetaData(anyString(), anyString(), anyString())).thenReturn(updatedMetaData); jvmResourceHandler.updateResourceMetaData(resourceIdentifier, resourceName, updatedMetaData); verify(mockJvmPersistence).updateResourceMetaData(eq(resourceIdentifier.jvmName), eq(resourceName), eq(updatedMetaData)); }
@Test public void testUpdateMetaDataCallsSuccessor() { final String updatedMetaData = "{\"updated\":\"meta-data\"}"; final String resourceName = "update-my-meta-data.txt"; ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName(resourceName).setGroupName("not-a-jvm").build(); jvmResourceHandler.updateResourceMetaData(notMeResourceIdentifier, resourceName, updatedMetaData); verify(mockSuccessor).updateResourceMetaData(eq(notMeResourceIdentifier), eq(resourceName), eq(updatedMetaData)); } |
### Question:
JvmResourceHandler extends ResourceHandler { @Override public Object getSelectedValue(ResourceIdentifier resourceIdentifier) { if (canHandle(resourceIdentifier)){ return jvmPersistenceService.findJvmByExactName(resourceIdentifier.jvmName); } else { return successor.getSelectedValue(resourceIdentifier); } } JvmResourceHandler(final ResourceDao resourceDao, final GroupPersistenceService groupPersistenceService,
final JvmPersistenceService jvmPersistenceService, final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testGetSelectedValue() { Jvm mockJvm = mock(Jvm.class); when(mockJvmPersistence.findJvmByExactName(anyString())).thenReturn(mockJvm); Jvm jvm = (Jvm) jvmResourceHandler.getSelectedValue(resourceIdentifier); assertEquals(mockJvm, jvm); }
@Test public void testGetSelectedValueCallsSuccessor() { ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName("jvm-resource").setGroupName("not-a-jvm").build(); jvmResourceHandler.getSelectedValue(notMeResourceIdentifier); verify(mockSuccessor).getSelectedValue(notMeResourceIdentifier); } |
### Question:
JvmResourceHandler extends ResourceHandler { @Override public List<String> getResourceNames(ResourceIdentifier resourceIdentifier) { if (canHandle(resourceIdentifier)){ return jvmPersistenceService.getResourceTemplateNames(resourceIdentifier.jvmName); } else { return successor.getResourceNames(resourceIdentifier); } } JvmResourceHandler(final ResourceDao resourceDao, final GroupPersistenceService groupPersistenceService,
final JvmPersistenceService jvmPersistenceService, final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testGetResourceNames() { jvmResourceHandler.getResourceNames(resourceIdentifier); verify(mockJvmPersistence).getResourceTemplateNames(anyString()); ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName("what-jvm").setGroupName("not-a-jvm").build(); jvmResourceHandler.getResourceNames(notMeResourceIdentifier); verify(mockSuccessor).getResourceNames(notMeResourceIdentifier); } |
### Question:
GroupLevelJvmResourceHandler extends ResourceHandler { @Override public Object getSelectedValue(ResourceIdentifier resourceIdentifier) { if (canHandle(resourceIdentifier)){ return null; } else { return successor.getSelectedValue(resourceIdentifier); } } GroupLevelJvmResourceHandler(final ResourceDao resourceDao, final GroupPersistenceService groupPersistenceService,
final JvmPersistenceService jvmPersistenceService, final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testGetSelectedValue() { Object selectedValue = groupLevelJvmResourceHandler.getSelectedValue(resourceIdentifier); assertNull(selectedValue); }
@Test public void testGetSelectedValueCallsSuccessor() { ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName("jvm-resource").setGroupName("not-a-jvm").build(); groupLevelJvmResourceHandler.getSelectedValue(notMeResourceIdentifier); verify(mockSuccessor).getSelectedValue(notMeResourceIdentifier); } |
### Question:
GroupLevelJvmResourceHandler extends ResourceHandler { @Override public List<String> getResourceNames(ResourceIdentifier resourceIdentifier) { if (canHandle(resourceIdentifier)){ throw new UnsupportedOperationException(); } else { return successor.getResourceNames(resourceIdentifier); } } GroupLevelJvmResourceHandler(final ResourceDao resourceDao, final GroupPersistenceService groupPersistenceService,
final JvmPersistenceService jvmPersistenceService, final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test (expected = UnsupportedOperationException.class) public void testGetResourceNames() { ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName("what-group-level-jvm").setGroupName("not-a-jvm").build(); groupLevelJvmResourceHandler.getResourceNames(notMeResourceIdentifier); verify(mockSuccessor).getResourceNames(notMeResourceIdentifier); groupLevelJvmResourceHandler.getResourceNames(resourceIdentifier); } |
### Question:
GroupLevelWebServerResourceHandler extends ResourceHandler { @Override public Object getSelectedValue(ResourceIdentifier resourceIdentifier) { if (canHandle(resourceIdentifier)){ return null; } else { return successor.getSelectedValue(resourceIdentifier); } } GroupLevelWebServerResourceHandler(final ResourceDao resourceDao,
final GroupPersistenceService groupPersistenceService,
final WebServerPersistenceService webServerPersistenceService,
final ResourceContentGeneratorService resourceContentGeneratorService,
final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test public void testGetSelectedValue() { Object selectedValue = groupLevelWebServerResourceHandler.getSelectedValue(resourceIdentifier); assertNull(selectedValue); }
@Test public void testGetSelectedValueCallsSuccessor() { ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName("webserver-resource").setGroupName("not-a-webserver").build(); groupLevelWebServerResourceHandler.getSelectedValue(notMeResourceIdentifier); verify(mockSuccessor).getSelectedValue(notMeResourceIdentifier); } |
### Question:
GroupLevelWebServerResourceHandler extends ResourceHandler { @Override public List<String> getResourceNames(ResourceIdentifier resourceIdentifier) { if (canHandle(resourceIdentifier)){ throw new UnsupportedOperationException(); } else { return successor.getResourceNames(resourceIdentifier); } } GroupLevelWebServerResourceHandler(final ResourceDao resourceDao,
final GroupPersistenceService groupPersistenceService,
final WebServerPersistenceService webServerPersistenceService,
final ResourceContentGeneratorService resourceContentGeneratorService,
final ResourceHandler successor); @Override ConfigTemplate fetchResource(final ResourceIdentifier resourceIdentifier); @Override CreateResourceResponseWrapper createResource(final ResourceIdentifier resourceIdentifier,
final ResourceTemplateMetaData metaData,
final String templateContent); @Override void deleteResource(final ResourceIdentifier resourceIdentifier); @Override String updateResourceMetaData(ResourceIdentifier resourceIdentifier, String resourceName, String metaData); @Override Object getSelectedValue(ResourceIdentifier resourceIdentifier); @Override List<String> getResourceNames(ResourceIdentifier resourceIdentifier); }### Answer:
@Test (expected = UnsupportedOperationException.class) public void testGetResourceNames() { ResourceIdentifier notMeResourceIdentifier = new ResourceIdentifier.Builder().setResourceName("what-group-level-web-server").setGroupName("not-a-web-server").build(); groupLevelWebServerResourceHandler.getResourceNames(notMeResourceIdentifier); verify(mockSuccessor).getResourceNames(notMeResourceIdentifier); groupLevelWebServerResourceHandler.getResourceNames(resourceIdentifier); } |
### Question:
Constraints { public static void remove(HTableDescriptor desc) { disable(desc); List<ImmutableBytesWritable> keys = new ArrayList<ImmutableBytesWritable>(); for (Map.Entry<ImmutableBytesWritable, ImmutableBytesWritable> e : desc .getValues().entrySet()) { String key = Bytes.toString((e.getKey().get())); String[] className = CONSTRAINT_HTD_ATTR_KEY_PATTERN.split(key); if (className.length == 2) { keys.add(e.getKey()); } } for (ImmutableBytesWritable key : keys) { desc.remove(key); } } private Constraints(); static void enable(HTableDescriptor desc); static void disable(HTableDescriptor desc); static void remove(HTableDescriptor desc); static boolean has(HTableDescriptor desc,
Class<? extends Constraint> clazz); static void add(HTableDescriptor desc,
Class<? extends Constraint>... constraints); static void add(HTableDescriptor desc,
Pair<Class<? extends Constraint>, Configuration>... constraints); static void add(HTableDescriptor desc,
Class<? extends Constraint> constraint, Configuration conf); static void setConfiguration(HTableDescriptor desc,
Class<? extends Constraint> clazz, Configuration configuration); static void remove(HTableDescriptor desc,
Class<? extends Constraint> clazz); static void enableConstraint(HTableDescriptor desc,
Class<? extends Constraint> clazz); static void disableConstraint(HTableDescriptor desc,
Class<? extends Constraint> clazz); static boolean enabled(HTableDescriptor desc,
Class<? extends Constraint> clazz); }### Answer:
@Test public void testRemoveUnsetConstraint() throws Throwable { HTableDescriptor desc = new HTableDescriptor(TableName.valueOf("table")); Constraints.remove(desc); Constraints.remove(desc, AlsoWorks.class); } |
### Question:
BufferChain { byte [] getBytes() { if (!hasRemaining()) throw new IllegalAccessError(); byte [] bytes = new byte [this.remaining]; int offset = 0; for (ByteBuffer bb: this.buffers) { System.arraycopy(bb.array(), bb.arrayOffset(), bytes, offset, bb.limit()); offset += bb.capacity(); } return bytes; } BufferChain(ByteBuffer ... buffers); }### Answer:
@Test public void testGetBackBytesWePutIn() { ByteBuffer[] bufs = wrapArrays(HELLO_WORLD_CHUNKS); BufferChain chain = new BufferChain(bufs); assertTrue(Bytes.equals(Bytes.toBytes("hello world"), chain.getBytes())); } |
### Question:
BufferChain { long write(GatheringByteChannel channel, int chunkSize) throws IOException { int chunkRemaining = chunkSize; ByteBuffer lastBuffer = null; int bufCount = 0; int restoreLimit = -1; while (chunkRemaining > 0 && bufferOffset + bufCount < buffers.length) { lastBuffer = buffers[bufferOffset + bufCount]; if (!lastBuffer.hasRemaining()) { bufferOffset++; continue; } bufCount++; if (lastBuffer.remaining() > chunkRemaining) { restoreLimit = lastBuffer.limit(); lastBuffer.limit(lastBuffer.position() + chunkRemaining); chunkRemaining = 0; break; } else { chunkRemaining -= lastBuffer.remaining(); } } assert lastBuffer != null; if (chunkRemaining == chunkSize) { assert !hasRemaining(); return 0; } try { long ret = channel.write(buffers, bufferOffset, bufCount); if (ret > 0) { remaining -= ret; } return ret; } finally { if (restoreLimit >= 0) { lastBuffer.limit(restoreLimit); } } } BufferChain(ByteBuffer ... buffers); }### Answer:
@Test public void testWithSpy() throws IOException { ByteBuffer[] bufs = new ByteBuffer[] { stringBuf("XXXhelloYYY", 3, 5), stringBuf(" ", 0, 1), stringBuf("XXXXworldY", 4, 5) }; BufferChain chain = new BufferChain(bufs); FileOutputStream fos = new FileOutputStream(tmpFile); FileChannel ch = Mockito.spy(fos.getChannel()); try { chain.write(ch, 2); assertEquals("he", Files.toString(tmpFile, Charsets.UTF_8)); chain.write(ch, 2); assertEquals("hell", Files.toString(tmpFile, Charsets.UTF_8)); chain.write(ch, 3); assertEquals("hello w", Files.toString(tmpFile, Charsets.UTF_8)); chain.write(ch, 8); assertEquals("hello world", Files.toString(tmpFile, Charsets.UTF_8)); } finally { ch.close(); fos.close(); } } |
### Question:
TableSplit extends InputSplit implements Writable, Comparable<TableSplit> { @Override public long getLength() { return length; } TableSplit(); @Deprecated TableSplit(final byte [] tableName, Scan scan, byte [] startRow, byte [] endRow,
final String location); TableSplit(TableName tableName, Scan scan, byte [] startRow, byte [] endRow,
final String location); TableSplit(TableName tableName, Scan scan, byte [] startRow, byte [] endRow,
final String location, long length); @Deprecated TableSplit(final byte [] tableName, byte[] startRow, byte[] endRow,
final String location); TableSplit(TableName tableName, byte[] startRow, byte[] endRow,
final String location); TableSplit(TableName tableName, byte[] startRow, byte[] endRow,
final String location, long length); Scan getScan(); byte [] getTableName(); TableName getTable(); byte [] getStartRow(); byte [] getEndRow(); String getRegionLocation(); @Override String[] getLocations(); @Override long getLength(); @Override void readFields(DataInput in); @Override void write(DataOutput out); @Override String toString(); @Override int compareTo(TableSplit split); @Override boolean equals(Object o); @Override int hashCode(); static final Log LOG; }### Answer:
@Test public void testLengthIsSerialized() throws Exception { TableSplit split1 = new TableSplit(TableName.valueOf("table"), "row-start".getBytes(), "row-end".getBytes(), "location", 666); TableSplit deserialized = new TableSplit(TableName.valueOf("table"), "row-start2".getBytes(), "row-end2".getBytes(), "location1"); ReflectionUtils.copy(new Configuration(), split1, deserialized); Assert.assertEquals(666, deserialized.getLength()); } |
### Question:
ScannerResource extends ResourceBase { @PUT @Consumes({MIMETYPE_XML, MIMETYPE_JSON, MIMETYPE_PROTOBUF, MIMETYPE_PROTOBUF_IETF}) public Response put(final ScannerModel model, final @Context UriInfo uriInfo) { if (LOG.isDebugEnabled()) { LOG.debug("PUT " + uriInfo.getAbsolutePath()); } return update(model, true, uriInfo); } ScannerResource(TableResource tableResource); @PUT @Consumes({MIMETYPE_XML, MIMETYPE_JSON, MIMETYPE_PROTOBUF, MIMETYPE_PROTOBUF_IETF}) Response put(final ScannerModel model,
final @Context UriInfo uriInfo); @POST @Consumes({MIMETYPE_XML, MIMETYPE_JSON, MIMETYPE_PROTOBUF, MIMETYPE_PROTOBUF_IETF}) Response post(final ScannerModel model,
final @Context UriInfo uriInfo); @Path("{scanner: .+}") ScannerInstanceResource getScannerInstanceResource(
final @PathParam("scanner") String id); }### Answer:
@Test public void testTableDoesNotExist() throws IOException, JAXBException { ScannerModel model = new ScannerModel(); StringWriter writer = new StringWriter(); marshaller.marshal(model, writer); byte[] body = Bytes.toBytes(writer.toString()); Response response = client.put("/" + NONEXISTENT_TABLE + "/scanner", Constants.MIMETYPE_XML, body); assertEquals(response.getCode(), 404); } |
### Question:
CopyTable extends Configured implements Tool { public CopyTable(Configuration conf) { super(conf); } CopyTable(Configuration conf); static Job createSubmittableJob(Configuration conf, String[] args); static void main(String[] args); @Override int run(String[] args); }### Answer:
@Test public void testCopyTable() throws Exception { final byte[] TABLENAME1 = Bytes.toBytes("testCopyTable1"); final byte[] TABLENAME2 = Bytes.toBytes("testCopyTable2"); final byte[] FAMILY = Bytes.toBytes("family"); final byte[] COLUMN1 = Bytes.toBytes("c1"); HTable t1 = TEST_UTIL.createTable(TABLENAME1, FAMILY); HTable t2 = TEST_UTIL.createTable(TABLENAME2, FAMILY); for (int i = 0; i < 10; i++) { Put p = new Put(Bytes.toBytes("row" + i)); p.add(FAMILY, COLUMN1, COLUMN1); t1.put(p); } CopyTable copy = new CopyTable(TEST_UTIL.getConfiguration()); assertEquals( 0, copy.run(new String[] { "--new.name=" + Bytes.toString(TABLENAME2), Bytes.toString(TABLENAME1) })); for (int i = 0; i < 10; i++) { Get g = new Get(Bytes.toBytes("row" + i)); Result r = t2.get(g); assertEquals(1, r.size()); assertTrue(CellUtil.matchingQualifier(r.rawCells()[0], COLUMN1)); } t1.close(); t2.close(); TEST_UTIL.deleteTable(TABLENAME1); TEST_UTIL.deleteTable(TABLENAME2); } |
### Question:
CopyTable extends Configured implements Tool { public static void main(String[] args) throws Exception { int ret = ToolRunner.run(new CopyTable(HBaseConfiguration.create()), args); System.exit(ret); } CopyTable(Configuration conf); static Job createSubmittableJob(Configuration conf, String[] args); static void main(String[] args); @Override int run(String[] args); }### Answer:
@Test public void testMainMethod() throws Exception { String[] emptyArgs = { "-h" }; PrintStream oldWriter = System.err; ByteArrayOutputStream data = new ByteArrayOutputStream(); PrintStream writer = new PrintStream(data); System.setErr(writer); SecurityManager SECURITY_MANAGER = System.getSecurityManager(); LauncherSecurityManager newSecurityManager= new LauncherSecurityManager(); System.setSecurityManager(newSecurityManager); try { CopyTable.main(emptyArgs); fail("should be exit"); } catch (SecurityException e) { assertEquals(1, newSecurityManager.getExitCode()); } finally { System.setErr(oldWriter); System.setSecurityManager(SECURITY_MANAGER); } assertTrue(data.toString().contains("rs.class")); assertTrue(data.toString().contains("Usage:")); } |
### Question:
JarFinder { public static String getJar(Class klass) { Preconditions.checkNotNull(klass, "klass"); ClassLoader loader = klass.getClassLoader(); if (loader != null) { String class_file = klass.getName().replaceAll("\\.", "/") + ".class"; try { for (Enumeration itr = loader.getResources(class_file); itr.hasMoreElements(); ) { URL url = (URL) itr.nextElement(); String path = url.getPath(); if (path.startsWith("file:")) { path = path.substring("file:".length()); } path = URLDecoder.decode(path, "UTF-8"); if ("jar".equals(url.getProtocol())) { path = URLDecoder.decode(path, "UTF-8"); return path.replaceAll("!.*$", ""); } else if ("file".equals(url.getProtocol())) { String klassName = klass.getName(); klassName = klassName.replace(".", "/") + ".class"; path = path.substring(0, path.length() - klassName.length()); File baseDir = new File(path); File testDir = new File(System.getProperty("test.build.dir", "target/test-dir")); testDir = testDir.getAbsoluteFile(); if (!testDir.exists()) { testDir.mkdirs(); } File tempJar = File.createTempFile("hadoop-", "", testDir); tempJar = new File(tempJar.getAbsolutePath() + ".jar"); createJar(baseDir, tempJar); return tempJar.getAbsolutePath(); } } } catch (IOException e) { throw new RuntimeException(e); } } return null; } static void jarDir(File dir, String relativePath, ZipOutputStream zos); static String getJar(Class klass); }### Answer:
@Test public void testJar() throws Exception { String jar = JarFinder.getJar(LogFactory.class); Assert.assertTrue(new File(jar).exists()); }
@Test public void testExpandedClasspath() throws Exception { String jar = JarFinder.getJar(TestJarFinder.class); Assert.assertTrue(new File(jar).exists()); } |
### Question:
HFileOutputFormat extends FileOutputFormat<ImmutableBytesWritable, KeyValue> { public static void configureIncrementalLoad(Job job, HTable table) throws IOException { HFileOutputFormat2.configureIncrementalLoad(job, table, HFileOutputFormat.class); } RecordWriter<ImmutableBytesWritable, KeyValue> getRecordWriter(
final TaskAttemptContext context); static void configureIncrementalLoad(Job job, HTable table); static final String DATABLOCK_ENCODING_OVERRIDE_CONF_KEY; }### Answer:
@Test public void testJobConfiguration() throws Exception { Job job = new Job(util.getConfiguration()); job.setWorkingDirectory(util.getDataTestDir("testJobConfiguration")); HTable table = Mockito.mock(HTable.class); setupMockStartKeys(table); HFileOutputFormat.configureIncrementalLoad(job, table); assertEquals(job.getNumReduceTasks(), 4); } |
### Question:
HFileOutputFormat2 extends FileOutputFormat<ImmutableBytesWritable, Cell> { public static void configureIncrementalLoad(Job job, HTable table) throws IOException { configureIncrementalLoad(job, table, HFileOutputFormat2.class); } RecordWriter<ImmutableBytesWritable, Cell> getRecordWriter(
final TaskAttemptContext context); static void configureIncrementalLoad(Job job, HTable table); static final String DATABLOCK_ENCODING_OVERRIDE_CONF_KEY; }### Answer:
@Test public void testJobConfiguration() throws Exception { Job job = new Job(util.getConfiguration()); job.setWorkingDirectory(util.getDataTestDir("testJobConfiguration")); HTable table = Mockito.mock(HTable.class); setupMockStartKeys(table); HFileOutputFormat2.configureIncrementalLoad(job, table); assertEquals(job.getNumReduceTasks(), 4); } |
### Question:
ReplicationSinkManager { void chooseSinks() { List<ServerName> slaveAddresses = replicationPeers.getRegionServersOfConnectedPeer(peerClusterId); Collections.shuffle(slaveAddresses, random); int numSinks = (int) Math.ceil(slaveAddresses.size() * ratio); sinks = slaveAddresses.subList(0, numSinks); lastUpdateToPeers = System.currentTimeMillis(); badReportCounts.clear(); } ReplicationSinkManager(HConnection conn, String peerClusterId,
ReplicationPeers replicationPeers, Configuration conf); SinkPeer getReplicationSink(); void reportBadSink(SinkPeer sinkPeer); }### Answer:
@Test public void testChooseSinks() { List<ServerName> serverNames = Lists.newArrayList(); for (int i = 0; i < 20; i++) { serverNames.add(mock(ServerName.class)); } when(replicationPeers.getRegionServersOfConnectedPeer(PEER_CLUSTER_ID)) .thenReturn(serverNames); sinkManager.chooseSinks(); assertEquals(2, sinkManager.getSinks().size()); } |
### Question:
ReplicationSinkManager { public void reportBadSink(SinkPeer sinkPeer) { ServerName serverName = sinkPeer.getServerName(); int badReportCount = (badReportCounts.containsKey(serverName) ? badReportCounts.get(serverName) : 0) + 1; badReportCounts.put(serverName, badReportCount); if (badReportCount > badSinkThreshold) { this.sinks.remove(serverName); if (sinks.isEmpty()) { chooseSinks(); } } } ReplicationSinkManager(HConnection conn, String peerClusterId,
ReplicationPeers replicationPeers, Configuration conf); SinkPeer getReplicationSink(); void reportBadSink(SinkPeer sinkPeer); }### Answer:
@Test public void testReportBadSink() { ServerName serverNameA = mock(ServerName.class); ServerName serverNameB = mock(ServerName.class); when(replicationPeers.getRegionServersOfConnectedPeer(PEER_CLUSTER_ID)).thenReturn( Lists.newArrayList(serverNameA, serverNameB)); sinkManager.chooseSinks(); assertEquals(1, sinkManager.getSinks().size()); SinkPeer sinkPeer = new SinkPeer(serverNameA, mock(AdminService.BlockingInterface.class)); sinkManager.reportBadSink(sinkPeer); assertEquals(1, sinkManager.getSinks().size()); } |
### Question:
ZooKeeperMainServer { public static void main(String args[]) throws Exception { String [] newArgs = args; if (!hasServer(args)) { Configuration conf = HBaseConfiguration.create(); String hostport = new ZooKeeperMainServer().parse(conf); if (hostport != null && hostport.length() > 0) { newArgs = new String[args.length + 2]; System.arraycopy(args, 0, newArgs, 2, args.length); newArgs[0] = "-server"; newArgs[1] = hostport; } } if (hasCommandLineArguments(args)) { HACK_UNTIL_ZOOKEEPER_1897_ZooKeeperMain zkm = new HACK_UNTIL_ZOOKEEPER_1897_ZooKeeperMain(newArgs); zkm.runCmdLine(); } else { ZooKeeperMain.main(newArgs); } } String parse(final Configuration c); static void main(String args[]); }### Answer:
@Test public void testCommandLineWorks() throws Exception { System.setSecurityManager(new NoExitSecurityManager()); HBaseTestingUtility htu = new HBaseTestingUtility(); htu.getConfiguration().setInt(HConstants.ZK_SESSION_TIMEOUT, 1000); htu.startMiniZKCluster(); try { ZooKeeperWatcher zkw = htu.getZooKeeperWatcher(); String znode = "/testCommandLineWorks"; ZKUtil.createWithParents(zkw, znode, HConstants.EMPTY_BYTE_ARRAY); ZKUtil.checkExists(zkw, znode); boolean exception = false; try { ZooKeeperMainServer.main(new String [] {"-server", "localhost:" + htu.getZkCluster().getClientPort(), "delete", znode}); } catch (ExitException ee) { exception = true; } assertTrue(exception); assertEquals(-1, ZKUtil.checkExists(zkw, znode)); } finally { htu.shutdownMiniZKCluster(); System.setSecurityManager(null); } } |
### Question:
ZKInterProcessReadWriteLock implements InterProcessReadWriteLock { public ZKInterProcessReadLock readLock(byte[] metadata) { return new ZKInterProcessReadLock(zkWatcher, znode, metadata, handler); } ZKInterProcessReadWriteLock(ZooKeeperWatcher zkWatcher, String znode,
MetadataHandler handler); ZKInterProcessReadLock readLock(byte[] metadata); ZKInterProcessWriteLock writeLock(byte[] metadata); }### Answer:
@Test(timeout = 30000) public void testReadLockDoesNotExcludeReaders() throws Exception { final String testName = "testReadLockDoesNotExcludeReaders"; final ZKInterProcessReadWriteLock readWriteLock = getReadWriteLock(testName); final CountDownLatch locksAcquiredLatch = new CountDownLatch(NUM_THREADS); final AtomicInteger locksHeld = new AtomicInteger(0); List<Future<Void>> results = Lists.newArrayList(); for (int i = 0; i < NUM_THREADS; ++i) { final String threadDesc = testName + i; results.add(executor.submit(new Callable<Void>() { @Override public Void call() throws Exception { ZKInterProcessReadLock readLock = readWriteLock.readLock(Bytes.toBytes(threadDesc)); readLock.acquire(); try { locksHeld.incrementAndGet(); locksAcquiredLatch.countDown(); Thread.sleep(1000); } finally { readLock.release(); locksHeld.decrementAndGet(); } return null; } })); } locksAcquiredLatch.await(); assertEquals(locksHeld.get(), NUM_THREADS); MultithreadedTestUtil.assertOnFutures(results); } |
### Question:
GroupingTableMap extends MapReduceBase implements TableMap<ImmutableBytesWritable,Result> { protected ImmutableBytesWritable createGroupKey(byte[][] vals) { if(vals == null) { return null; } StringBuilder sb = new StringBuilder(); for(int i = 0; i < vals.length; i++) { if(i > 0) { sb.append(" "); } sb.append(Bytes.toString(vals[i])); } return new ImmutableBytesWritable(Bytes.toBytes(sb.toString())); } @SuppressWarnings("unchecked") static void initJob(String table, String columns, String groupColumns,
Class<? extends TableMap> mapper, JobConf job); @Override void configure(JobConf job); void map(ImmutableBytesWritable key, Result value,
OutputCollector<ImmutableBytesWritable,Result> output,
Reporter reporter); static final String GROUP_COLUMNS; }### Answer:
@Test @SuppressWarnings({ "deprecation" }) public void shouldReturnNullFromCreateGroupKey() throws Exception { GroupingTableMap gTableMap = null; try { gTableMap = new GroupingTableMap(); assertNull(gTableMap.createGroupKey(null)); } finally { if(gTableMap != null) gTableMap.close(); } } |
### Question:
IdentityTableMap extends MapReduceBase implements TableMap<ImmutableBytesWritable, Result> { public void map(ImmutableBytesWritable key, Result value, OutputCollector<ImmutableBytesWritable,Result> output, Reporter reporter) throws IOException { output.collect(key, value); } IdentityTableMap(); @SuppressWarnings("unchecked") static void initJob(String table, String columns,
Class<? extends TableMap> mapper, JobConf job); void map(ImmutableBytesWritable key, Result value,
OutputCollector<ImmutableBytesWritable,Result> output,
Reporter reporter); }### Answer:
@Test @SuppressWarnings({ "deprecation", "unchecked" }) public void shouldCollectPredefinedTimes() throws IOException { int recordNumber = 999; Result resultMock = mock(Result.class); IdentityTableMap identityTableMap = null; try { Reporter reporterMock = mock(Reporter.class); identityTableMap = new IdentityTableMap(); ImmutableBytesWritable bytesWritableMock = mock(ImmutableBytesWritable.class); OutputCollector<ImmutableBytesWritable, Result> outputCollectorMock = mock(OutputCollector.class); for (int i = 0; i < recordNumber; i++) identityTableMap.map(bytesWritableMock, resultMock, outputCollectorMock, reporterMock); verify(outputCollectorMock, times(recordNumber)).collect( Mockito.any(ImmutableBytesWritable.class), Mockito.any(Result.class)); } finally { if (identityTableMap != null) identityTableMap.close(); } } |
### Question:
RowCounter extends Configured implements Tool { static int printUsage() { System.out.println(NAME + " <outputdir> <tablename> <column1> [<column2>...]"); return -1; } JobConf createSubmittableJob(String[] args); int run(final String[] args); static void main(String[] args); }### Answer:
@Test @SuppressWarnings("deprecation") public void shouldPrintUsage() throws Exception { String expectedOutput = "rowcounter <outputdir> <tablename> <column1> [<column2>...]"; String result = new OutputReader(System.out) { @Override void doRead() { assertEquals(-1, RowCounter.printUsage()); } }.read(); assertTrue(result.startsWith(expectedOutput)); } |
### Question:
RowCounter extends Configured implements Tool { public int run(final String[] args) throws Exception { if (args.length < 3) { System.err.println("ERROR: Wrong number of parameters: " + args.length); return printUsage(); } JobClient.runJob(createSubmittableJob(args)); return 0; } JobConf createSubmittableJob(String[] args); int run(final String[] args); static void main(String[] args); }### Answer:
@Test @SuppressWarnings("deprecation") public void shouldExitAndPrintUsageSinceParameterNumberLessThanThree() throws Exception { final String[] args = new String[] { "one", "two" }; String line = "ERROR: Wrong number of parameters: " + args.length; String result = new OutputReader(System.err) { @Override void doRead() throws Exception { assertEquals(-1, new RowCounter().run(args)); } }.read(); assertTrue(result.startsWith(line)); } |
### Question:
RowCounter extends Configured implements Tool { public JobConf createSubmittableJob(String[] args) throws IOException { JobConf c = new JobConf(getConf(), getClass()); c.setJobName(NAME); StringBuilder sb = new StringBuilder(); final int columnoffset = 2; for (int i = columnoffset; i < args.length; i++) { if (i > columnoffset) { sb.append(" "); } sb.append(args[i]); } TableMapReduceUtil.initTableMapJob(args[1], sb.toString(), RowCounterMapper.class, ImmutableBytesWritable.class, Result.class, c); c.setNumReduceTasks(0); FileOutputFormat.setOutputPath(c, new Path(args[0])); return c; } JobConf createSubmittableJob(String[] args); int run(final String[] args); static void main(String[] args); }### Answer:
@Test @SuppressWarnings({ "deprecation" }) public void shouldCreateAndRunSubmittableJob() throws Exception { RowCounter rCounter = new RowCounter(); rCounter.setConf(HBaseConfiguration.create()); String[] args = new String[] { "\temp", "tableA", "column1", "column2", "column3" }; JobConf jobConfig = rCounter.createSubmittableJob(args); assertNotNull(jobConfig); assertEquals(0, jobConfig.getNumReduceTasks()); assertEquals("rowcounter", jobConfig.getJobName()); assertEquals(jobConfig.getMapOutputValueClass(), Result.class); assertEquals(jobConfig.getMapperClass(), RowCounterMapper.class); assertEquals(jobConfig.get(TableInputFormat.COLUMN_LIST), Joiner.on(' ') .join("column1", "column2", "column3")); assertEquals(jobConfig.getMapOutputKeyClass(), ImmutableBytesWritable.class); } |
### Question:
StochasticLoadBalancer extends BaseLoadBalancer { @Override public void setClusterStatus(ClusterStatus st) { super.setClusterStatus(st); regionFinder.setClusterStatus(st); updateRegionLoad(); for(CostFromRegionLoadFunction cost : regionLoadFunctions) { cost.setClusterStatus(st); } } @Override void setConf(Configuration conf); @Override void setClusterStatus(ClusterStatus st); @Override void setMasterServices(MasterServices masterServices); @Override List<RegionPlan> balanceCluster(Map<ServerName, List<HRegionInfo>> clusterState); }### Answer:
@Test public void testKeepRegionLoad() throws Exception { ServerName sn = ServerName.valueOf("test:8080", 100); int numClusterStatusToAdd = 20000; for (int i = 0; i < numClusterStatusToAdd; i++) { ServerLoad sl = mock(ServerLoad.class); RegionLoad rl = mock(RegionLoad.class); when(rl.getStores()).thenReturn(i); Map<byte[], RegionLoad> regionLoadMap = new TreeMap<byte[], RegionLoad>(Bytes.BYTES_COMPARATOR); regionLoadMap.put(Bytes.toBytes(REGION_KEY), rl); when(sl.getRegionsLoad()).thenReturn(regionLoadMap); ClusterStatus clusterStatus = mock(ClusterStatus.class); when(clusterStatus.getServers()).thenReturn(Arrays.asList(sn)); when(clusterStatus.getLoad(sn)).thenReturn(sl); loadBalancer.setClusterStatus(clusterStatus); } assertTrue(loadBalancer.loads.get(REGION_KEY) != null); assertTrue(loadBalancer.loads.get(REGION_KEY).size() == 15); Queue<RegionLoad> loads = loadBalancer.loads.get(REGION_KEY); int i = 0; while(loads.size() > 0) { RegionLoad rl = loads.remove(); assertEquals(i + (numClusterStatusToAdd - 15), rl.getStores()); i ++; } } |
### Question:
StaticUserWebFilter extends FilterInitializer { static String getUsernameFromConf(Configuration conf) { String oldStyleUgi = conf.get(DEPRECATED_UGI_KEY); if (oldStyleUgi != null) { LOG.warn(DEPRECATED_UGI_KEY + " should not be used. Instead, use " + HBASE_HTTP_STATIC_USER + "."); String[] parts = oldStyleUgi.split(","); return parts[0]; } else { return conf.get(HBASE_HTTP_STATIC_USER, DEFAULT_HBASE_HTTP_STATIC_USER); } } @Override void initFilter(FilterContainer container, Configuration conf); }### Answer:
@Test public void testOldStyleConfiguration() { Configuration conf = new Configuration(); conf.set("dfs.web.ugi", "joe,group1,group2"); assertEquals("joe", StaticUserWebFilter.getUsernameFromConf(conf)); }
@Test public void testConfiguration() { Configuration conf = new Configuration(); conf.set(CommonConfigurationKeys.HADOOP_HTTP_STATIC_USER, "dr.stack"); assertEquals("dr.stack", StaticUserWebFilter.getUsernameFromConf(conf)); } |
### Question:
SplitLogManager extends ZooKeeperListener { public long splitLogDistributed(final Path logDir) throws IOException { List<Path> logDirs = new ArrayList<Path>(); logDirs.add(logDir); return splitLogDistributed(logDirs); } SplitLogManager(ZooKeeperWatcher zkw, final Configuration conf,
Stoppable stopper, MasterServices master, ServerName serverName); SplitLogManager(ZooKeeperWatcher zkw, Configuration conf, Stoppable stopper,
MasterServices master, ServerName serverName, TaskFinisher tf); long splitLogDistributed(final Path logDir); long splitLogDistributed(final List<Path> logDirs); long splitLogDistributed(final Set<ServerName> serverNames, final List<Path> logDirs,
PathFilter filter); static void deleteRecoveringRegionZNodes(ZooKeeperWatcher watcher, List<String> regions); @Override void nodeDataChanged(String path); void stop(); static long parseLastFlushedSequenceIdFrom(final byte[] bytes); static boolean isRegionMarkedRecoveringInZK(ZooKeeperWatcher zkw, String regionEncodedName); static RegionStoreSequenceIds getRegionFlushedSequenceId(ZooKeeperWatcher zkw,
String serverName, String encodedRegionName); void setRecoveryMode(boolean isForInitialization); RecoveryMode getRecoveryMode(); static final int DEFAULT_TIMEOUT; static final int DEFAULT_ZK_RETRIES; static final int DEFAULT_MAX_RESUBMIT; static final int DEFAULT_UNASSIGNED_TIMEOUT; public boolean ignoreZKDeleteForTesting; }### Answer:
@Test public void testEmptyLogDir() throws Exception { LOG.info("testEmptyLogDir"); slm = new SplitLogManager(zkw, conf, stopper, master, DUMMY_MASTER); FileSystem fs = TEST_UTIL.getTestFileSystem(); Path emptyLogDirPath = new Path(fs.getWorkingDirectory(), UUID.randomUUID().toString()); fs.mkdirs(emptyLogDirPath); slm.splitLogDistributed(emptyLogDirPath); assertFalse(fs.exists(emptyLogDirPath)); } |
### Question:
HtmlQuoting { public static boolean needsQuoting(byte[] data, int off, int len) { if (off+len > data.length) { throw new IllegalStateException("off+len=" + off+len + " should be lower" + " than data length=" + data.length); } for(int i=off; i< off+len; ++i) { switch(data[i]) { case '&': case '<': case '>': case '\'': case '"': return true; default: break; } } return false; } static boolean needsQuoting(byte[] data, int off, int len); static boolean needsQuoting(String str); static void quoteHtmlChars(OutputStream output, byte[] buffer,
int off, int len); static String quoteHtmlChars(String item); static OutputStream quoteOutputStream(final OutputStream out
); static String unquoteHtmlChars(String item); static void main(String[] args); }### Answer:
@Test public void testNeedsQuoting() throws Exception { assertTrue(HtmlQuoting.needsQuoting("abcde>")); assertTrue(HtmlQuoting.needsQuoting("<abcde")); assertTrue(HtmlQuoting.needsQuoting("abc'de")); assertTrue(HtmlQuoting.needsQuoting("abcde\"")); assertTrue(HtmlQuoting.needsQuoting("&")); assertFalse(HtmlQuoting.needsQuoting("")); assertFalse(HtmlQuoting.needsQuoting("ab\ncdef")); assertFalse(HtmlQuoting.needsQuoting(null)); } |
### Question:
ServerNonceManager { public void endOperation(long group, long nonce, boolean success) { if (nonce == HConstants.NO_NONCE) return; NonceKey nk = new NonceKey(group, nonce); OperationContext newResult = nonces.get(nk); assert newResult != null; synchronized (newResult) { assert newResult.getState() == OperationContext.WAIT; newResult.setState(success ? OperationContext.DONT_PROCEED : OperationContext.PROCEED); if (success) { newResult.reportActivity(); } else { OperationContext val = nonces.remove(nk); assert val == newResult; } if (newResult.hasWait()) { LOG.debug("Conflict with running op ended: " + nk + ", " + newResult); newResult.notifyAll(); } } } ServerNonceManager(Configuration conf); @VisibleForTesting void setConflictWaitIterationMs(int conflictWaitIterationMs); boolean startOperation(long group, long nonce, Stoppable stoppable); void endOperation(long group, long nonce, boolean success); void reportOperationFromWal(long group, long nonce, long writeTime); Chore createCleanupChore(Stoppable stoppable); static final String HASH_NONCE_GRACE_PERIOD_KEY; }### Answer:
@Test public void testNoEndWithoutStart() { ServerNonceManager nm = createManager(); try { nm.endOperation(NO_NONCE, 1, true); fail("Should have thrown"); } catch (AssertionError err) {} } |
### Question:
RegionSplitPolicy extends Configured { public static RegionSplitPolicy create(HRegion region, Configuration conf) throws IOException { Class<? extends RegionSplitPolicy> clazz = getSplitPolicyClass( region.getTableDesc(), conf); RegionSplitPolicy policy = ReflectionUtils.newInstance(clazz, conf); policy.configureForRegion(region); return policy; } static RegionSplitPolicy create(HRegion region,
Configuration conf); static Class<? extends RegionSplitPolicy> getSplitPolicyClass(
HTableDescriptor htd, Configuration conf); }### Answer:
@Test public void testCreateDefault() throws IOException { conf.setLong(HConstants.HREGION_MAX_FILESIZE, 1234L); ConstantSizeRegionSplitPolicy policy = (ConstantSizeRegionSplitPolicy)RegionSplitPolicy.create( mockRegion, conf); assertEquals(1234L, policy.getDesiredMaxFileSize()); htd.setMaxFileSize(9999L); policy = (ConstantSizeRegionSplitPolicy)RegionSplitPolicy.create( mockRegion, conf); assertEquals(9999L, policy.getDesiredMaxFileSize()); }
@Test public void testConstantSizePolicy() throws IOException { htd.setMaxFileSize(1024L); ConstantSizeRegionSplitPolicy policy = (ConstantSizeRegionSplitPolicy)RegionSplitPolicy.create(mockRegion, conf); doConstantSizePolicyTests(policy); }
@Test public void testCreateDefault() throws IOException { conf.setLong(HConstants.HREGION_MAX_FILESIZE, 1234L); ConstantSizeRegionSplitPolicy policy = (ConstantSizeRegionSplitPolicy)RegionSplitPolicy.create( mockRegion, conf); assertWithinJitter(1234L, policy.getDesiredMaxFileSize()); htd.setMaxFileSize(9999L); policy = (ConstantSizeRegionSplitPolicy)RegionSplitPolicy.create( mockRegion, conf); assertWithinJitter(9999L, policy.getDesiredMaxFileSize()); } |
### Question:
RegionSplitPolicy extends Configured { protected byte[] getSplitPoint() { byte[] explicitSplitPoint = this.region.getExplicitSplitPoint(); if (explicitSplitPoint != null) { return explicitSplitPoint; } Map<byte[], Store> stores = region.getStores(); byte[] splitPointFromLargestStore = null; long largestStoreSize = 0; for (Store s : stores.values()) { byte[] splitPoint = s.getSplitPoint(); long storeSize = s.getSize(); if (splitPoint != null && largestStoreSize < storeSize) { splitPointFromLargestStore = splitPoint; largestStoreSize = storeSize; } } return splitPointFromLargestStore; } static RegionSplitPolicy create(HRegion region,
Configuration conf); static Class<? extends RegionSplitPolicy> getSplitPolicyClass(
HTableDescriptor htd, Configuration conf); }### Answer:
@Test public void testGetSplitPoint() throws IOException { ConstantSizeRegionSplitPolicy policy = (ConstantSizeRegionSplitPolicy)RegionSplitPolicy.create(mockRegion, conf); assertFalse(policy.shouldSplit()); assertNull(policy.getSplitPoint()); HStore mockStore = Mockito.mock(HStore.class); Mockito.doReturn(2000L).when(mockStore).getSize(); Mockito.doReturn(true).when(mockStore).canSplit(); Mockito.doReturn(Bytes.toBytes("store 1 split")) .when(mockStore).getSplitPoint(); stores.put(new byte[]{1}, mockStore); assertEquals("store 1 split", Bytes.toString(policy.getSplitPoint())); HStore mockStore2 = Mockito.mock(HStore.class); Mockito.doReturn(4000L).when(mockStore2).getSize(); Mockito.doReturn(true).when(mockStore2).canSplit(); Mockito.doReturn(Bytes.toBytes("store 2 split")) .when(mockStore2).getSplitPoint(); stores.put(new byte[]{2}, mockStore2); assertEquals("store 2 split", Bytes.toString(policy.getSplitPoint())); } |
### Question:
Compressor { static short toShort(byte hi, byte lo) { short s = (short) (((hi & 0xFF) << 8) | (lo & 0xFF)); Preconditions.checkArgument(s >= 0); return s; } static void main(String[] args); }### Answer:
@Test public void testToShort() { short s = 1; assertEquals(s, Compressor.toShort((byte)0, (byte)1)); s <<= 8; assertEquals(s, Compressor.toShort((byte)1, (byte)0)); }
@Test (expected = IllegalArgumentException.class) public void testNegativeToShort() { Compressor.toShort((byte)0xff, (byte)0xff); } |
### Question:
MetaMigrationConvertingToPB { static boolean isMetaTableUpdated(final CatalogTracker catalogTracker) throws IOException { List<Result> results = MetaReader.fullScanOfMeta(catalogTracker); if (results == null || results.isEmpty()) { LOG.info("hbase:meta doesn't have any entries to update."); return true; } for (Result r : results) { byte[] value = r.getValue(HConstants.CATALOG_FAMILY, HConstants.REGIONINFO_QUALIFIER); if (!isMigrated(value)) { return false; } } return true; } static long updateMetaIfNecessary(final MasterServices services); }### Answer:
@Test public void testMetaUpdatedFlagInROOT() throws Exception { HMaster master = TEST_UTIL.getMiniHBaseCluster().getMaster(); boolean metaUpdated = MetaMigrationConvertingToPB. isMetaTableUpdated(master.getCatalogTracker()); assertEquals(true, metaUpdated); verifyMetaRowsAreUpdated(master.getCatalogTracker()); } |
### Question:
JMXListener implements Coprocessor { @Override public void start(CoprocessorEnvironment env) throws IOException { int rmiRegistryPort = -1; int rmiConnectorPort = -1; Configuration conf = env.getConfiguration(); if (env instanceof MasterCoprocessorEnvironment) { LOG.error("JMXListener should not be loaded in Master Environment!"); } else if (env instanceof RegionServerCoprocessorEnvironment) { rmiRegistryPort = conf.getInt("regionserver" + RMI_REGISTRY_PORT_CONF_KEY, defRMIRegistryPort); rmiConnectorPort = conf.getInt("regionserver" + RMI_CONNECTOR_PORT_CONF_KEY, rmiRegistryPort); LOG.info("RegionServer rmiRegistryPort:" + rmiRegistryPort + ",RegionServer rmiConnectorPort:" + rmiConnectorPort); } else if (env instanceof RegionCoprocessorEnvironment) { LOG.error("JMXListener should not be loaded in Region Environment!"); } synchronized(JMXListener.class) { if (jmxCS != null) { LOG.info("JMXListener has been started at Registry port " + rmiRegistryPort); } else { startConnectorServer(rmiRegistryPort, rmiConnectorPort); } } } static JMXServiceURL buildJMXServiceURL(int rmiRegistryPort,
int rmiConnectorPort); void startConnectorServer(int rmiRegistryPort, int rmiConnectorPort); void stopConnectorServer(); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); static final Log LOG; static final String RMI_REGISTRY_PORT_CONF_KEY; static final String RMI_CONNECTOR_PORT_CONF_KEY; static int defRMIRegistryPort; }### Answer:
@Test public void testStart() throws Exception { JMXConnector connector = JMXConnectorFactory.connect( JMXListener.buildJMXServiceURL(connectorPort,connectorPort)); MBeanServerConnection mb = connector.getMBeanServerConnection(); String domain = mb.getDefaultDomain(); Assert.assertTrue("default domain is not correct", !domain.isEmpty()); connector.close(); } |
### Question:
JMXListener implements Coprocessor { @Override public void stop(CoprocessorEnvironment env) throws IOException { stopConnectorServer(); } static JMXServiceURL buildJMXServiceURL(int rmiRegistryPort,
int rmiConnectorPort); void startConnectorServer(int rmiRegistryPort, int rmiConnectorPort); void stopConnectorServer(); @Override void start(CoprocessorEnvironment env); @Override void stop(CoprocessorEnvironment env); static final Log LOG; static final String RMI_REGISTRY_PORT_CONF_KEY; static final String RMI_CONNECTOR_PORT_CONF_KEY; static int defRMIRegistryPort; }### Answer:
@Test public void testStop() throws Exception { MiniHBaseCluster cluster = UTIL.getHBaseCluster(); LOG.info("shutdown hbase cluster..."); cluster.shutdown(); LOG.info("wait for the hbase cluster shutdown..."); cluster.waitUntilShutDown(); JMXConnector connector = JMXConnectorFactory.newJMXConnector( JMXListener.buildJMXServiceURL(connectorPort,connectorPort), null); expectedEx.expect(IOException.class); connector.connect(); } |
### Question:
KeyLocker { public ReentrantLock acquireLock(K key) { if (key == null) throw new IllegalArgumentException("key must not be null"); Pair<KeyLock<K>, AtomicInteger> lock; synchronized (this) { lock = locks.get(key); if (lock == null) { lock = new Pair<KeyLock<K>, AtomicInteger>( new KeyLock<K>(this, key), new AtomicInteger(1)); locks.put(key, lock); } else { lock.getSecond().incrementAndGet(); } } lock.getFirst().lock(); return lock.getFirst(); } ReentrantLock acquireLock(K key); Map<K, Lock> acquireLocks(final Set<K> keys); }### Answer:
@Test public void testLocker(){ KeyLocker<String> locker = new KeyLocker(); ReentrantLock lock1 = locker.acquireLock("l1"); Assert.assertTrue(lock1.isHeldByCurrentThread()); ReentrantLock lock2 = locker.acquireLock("l2"); Assert.assertTrue(lock2.isHeldByCurrentThread()); Assert.assertTrue(lock1 != lock2); ReentrantLock lock20 = locker.acquireLock("l2"); Assert.assertTrue(lock20 == lock2); Assert.assertTrue(lock2.isHeldByCurrentThread()); Assert.assertTrue(lock20.isHeldByCurrentThread()); lock20.unlock(); Assert.assertTrue(lock20.isHeldByCurrentThread()); lock2.unlock(); Assert.assertFalse(lock20.isHeldByCurrentThread()); ReentrantLock lock200 = locker.acquireLock("l2"); Assert.assertTrue(lock2 != lock200); lock200.unlock(); Assert.assertFalse(lock200.isHeldByCurrentThread()); Assert.assertTrue(lock1.isHeldByCurrentThread()); lock1.unlock(); Assert.assertFalse(lock1.isHeldByCurrentThread()); } |
### Question:
Counter { public void increment() { add(1); } Counter(); Counter(long initValue); private Counter(Cell initCell); void add(long delta); void increment(); void decrement(); void set(long value); long get(); @Override String toString(); }### Answer:
@Test public void testIncrement() throws Exception { for(int threadCount : THREAD_COUNTS) { final Counter counter = new Counter(); execute(new Operation() { @Override public void execute() { counter.increment(); } }, threadCount); Assert.assertEquals(threadCount * (long)DATA_COUNT, counter.get()); } } |
### Question:
DrainBarrier { public void stopAndDrainOpsOnce() throws InterruptedException { stopAndDrainOps(false); } boolean beginOp(); @edu.umd.cs.findbugs.annotations.SuppressWarnings(value="NN_NAKED_NOTIFY", justification="First, we do change the state before notify, 2nd, it doesn't even matter") void endOp(); void stopAndDrainOps(); void stopAndDrainOpsOnce(); }### Answer:
@Test public void testMultipleStopOnceAssert() throws Exception { DrainBarrier barrier = new DrainBarrier(); barrier.stopAndDrainOpsOnce(); try { barrier.stopAndDrainOpsOnce(); fail("Should have asserted"); } catch (AssertionError e) { } } |
### Question:
DrainBarrier { public void stopAndDrainOps() throws InterruptedException { stopAndDrainOps(true); } boolean beginOp(); @edu.umd.cs.findbugs.annotations.SuppressWarnings(value="NN_NAKED_NOTIFY", justification="First, we do change the state before notify, 2nd, it doesn't even matter") void endOp(); void stopAndDrainOps(); void stopAndDrainOpsOnce(); }### Answer:
@Test public void testMultipleSloppyStopsHaveNoEffect() throws Exception { DrainBarrier barrier = new DrainBarrier(); barrier.stopAndDrainOps(); barrier.stopAndDrainOps(); } |
### Question:
FSHDFSUtils extends FSUtils { boolean recoverLease(final DistributedFileSystem dfs, final int nbAttempt, final Path p, final long startWaiting) throws FileNotFoundException { boolean recovered = false; try { recovered = dfs.recoverLease(p); LOG.info("recoverLease=" + recovered + ", " + getLogMessageDetail(nbAttempt, p, startWaiting)); } catch (IOException e) { if (e instanceof LeaseExpiredException && e.getMessage().contains("File does not exist")) { throw new FileNotFoundException("The given HLog wasn't found at " + p); } else if (e instanceof FileNotFoundException) { throw (FileNotFoundException)e; } LOG.warn(getLogMessageDetail(nbAttempt, p, startWaiting), e); } return recovered; } static boolean isSameHdfs(Configuration conf, FileSystem srcFs, FileSystem desFs); @Override void recoverFileLease(final FileSystem fs, final Path p,
Configuration conf, CancelableProgressable reporter); }### Answer:
@Test (timeout = 30000) public void testRecoverLease() throws IOException { HTU.getConfiguration().setInt("hbase.lease.recovery.dfs.timeout", 1000); CancelableProgressable reporter = Mockito.mock(CancelableProgressable.class); Mockito.when(reporter.progress()).thenReturn(true); DistributedFileSystem dfs = Mockito.mock(DistributedFileSystem.class); Mockito.when(dfs.recoverLease(FILE)). thenReturn(false).thenReturn(false).thenReturn(false).thenReturn(false).thenReturn(true); assertTrue(this.fsHDFSUtils.recoverDFSFileLease(dfs, FILE, HTU.getConfiguration(), reporter)); Mockito.verify(dfs, Mockito.times(5)).recoverLease(FILE); assertTrue((EnvironmentEdgeManager.currentTimeMillis() - this.startTime) > (3 * HTU.getConfiguration().getInt("hbase.lease.recovery.dfs.timeout", 61000))); } |
### Question:
ConcatenatedLists implements Collection<T> { public void addSublist(List<T> items) { if (!items.isEmpty()) { this.components.add(items); this.size += items.size(); } } void addAllSublists(List<? extends List<T>> items); void addSublist(List<T> items); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean containsAll(Collection<?> c); @Override Object[] toArray(); @Override @SuppressWarnings("unchecked") U[] toArray(U[] a); @Override boolean add(T e); @Override boolean remove(Object o); @Override boolean addAll(Collection<? extends T> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override java.util.Iterator<T> iterator(); }### Answer:
@Test public void testOneOne() { ConcatenatedLists<Long> c = new ConcatenatedLists<Long>(); c.addSublist(Arrays.asList(0L)); verify(c, 0); }
@Test public void testOneMany() { ConcatenatedLists<Long> c = new ConcatenatedLists<Long>(); c.addSublist(Arrays.asList(0L, 1L, 2L)); verify(c, 2); } |
### Question:
AES extends Cipher { @VisibleForTesting SecureRandom getRNG() { return rng; } AES(CipherProvider provider); @Override String getName(); @Override int getKeyLength(); @Override int getIvLength(); @Override Key getRandomKey(); @Override Encryptor getEncryptor(); @Override Decryptor getDecryptor(); @Override OutputStream createEncryptionStream(OutputStream out, Context context, byte[] iv); @Override OutputStream createEncryptionStream(OutputStream out, Encryptor e); @Override InputStream createDecryptionStream(InputStream in, Context context, byte[] iv); @Override InputStream createDecryptionStream(InputStream in, Decryptor d); static final int KEY_LENGTH; static final int KEY_LENGTH_BITS; static final int IV_LENGTH; static final String CIPHER_MODE_KEY; static final String CIPHER_PROVIDER_KEY; static final String RNG_ALGORITHM_KEY; static final String RNG_PROVIDER_KEY; }### Answer:
@Test public void testAlternateRNG() throws Exception { Security.addProvider(new TestProvider()); Configuration conf = new Configuration(); conf.set(AES.RNG_ALGORITHM_KEY, "TestRNG"); conf.set(AES.RNG_PROVIDER_KEY, "TEST"); DefaultCipherProvider.getInstance().setConf(conf); AES aes = new AES(DefaultCipherProvider.getInstance()); assertEquals("AES did not find alternate RNG", aes.getRNG().getAlgorithm(), "TestRNG"); } |
### Question:
LRUDictionary implements Dictionary { @Override public short addEntry(byte[] data, int offset, int length) { if (length <= 0) return NOT_IN_DICTIONARY; return backingStore.put(data, offset, length); } @Override byte[] getEntry(short idx); @Override void init(int initialSize); @Override short findEntry(byte[] data, int offset, int length); @Override short addEntry(byte[] data, int offset, int length); @Override void clear(); }### Answer:
@Test public void testPassingSameArrayToAddEntry() { int len = HConstants.CATALOG_FAMILY.length; int index = testee.addEntry(HConstants.CATALOG_FAMILY, 0, len); assertFalse(index == testee.addEntry(HConstants.CATALOG_FAMILY, 0, len)); assertFalse(index == testee.addEntry(HConstants.CATALOG_FAMILY, 0, len)); } |
### Question:
LRUDictionary implements Dictionary { @Override public short findEntry(byte[] data, int offset, int length) { short ret = backingStore.findIdx(data, offset, length); if (ret == NOT_IN_DICTIONARY) { addEntry(data, offset, length); } return ret; } @Override byte[] getEntry(short idx); @Override void init(int initialSize); @Override short findEntry(byte[] data, int offset, int length); @Override short addEntry(byte[] data, int offset, int length); @Override void clear(); }### Answer:
@Test public void TestLRUPolicy(){ for (int i = 0; i < Short.MAX_VALUE; i++) { testee.findEntry((BigInteger.valueOf(i)).toByteArray(), 0, (BigInteger.valueOf(i)).toByteArray().length); } assertTrue(testee.findEntry(BigInteger.ZERO.toByteArray(), 0, BigInteger.ZERO.toByteArray().length) != -1); assertTrue(testee.findEntry(BigInteger.valueOf(Integer.MAX_VALUE).toByteArray(), 0, BigInteger.valueOf(Integer.MAX_VALUE).toByteArray().length) == -1); assertTrue(testee.findEntry(BigInteger.valueOf(Integer.MAX_VALUE).toByteArray(), 0, BigInteger.valueOf(Integer.MAX_VALUE).toByteArray().length) != -1); assertTrue(testee.findEntry(BigInteger.ZERO.toByteArray(), 0, BigInteger.ZERO.toByteArray().length) != -1); for(int i = 1; i < Short.MAX_VALUE; i++) { assertTrue(testee.findEntry(BigInteger.valueOf(i).toByteArray(), 0, BigInteger.valueOf(i).toByteArray().length) == -1); } for (int i = 0; i < Short.MAX_VALUE; i++) { assertTrue(testee.findEntry(BigInteger.valueOf(i).toByteArray(), 0, BigInteger.valueOf(i).toByteArray().length) != -1); } } |
### Question:
FSHDFSUtils extends FSUtils { private boolean isFileClosed(final DistributedFileSystem dfs, final Method m, final Path p) { try { return (Boolean) m.invoke(dfs, p); } catch (SecurityException e) { LOG.warn("No access", e); } catch (Exception e) { LOG.warn("Failed invocation for " + p.toString(), e); } return false; } static boolean isSameHdfs(Configuration conf, FileSystem srcFs, FileSystem desFs); @Override void recoverFileLease(final FileSystem fs, final Path p,
Configuration conf, CancelableProgressable reporter); }### Answer:
@Test (timeout = 30000) public void testIsFileClosed() throws IOException { HTU.getConfiguration().setInt("hbase.lease.recovery.dfs.timeout", 100000); CancelableProgressable reporter = Mockito.mock(CancelableProgressable.class); Mockito.when(reporter.progress()).thenReturn(true); IsFileClosedDistributedFileSystem dfs = Mockito.mock(IsFileClosedDistributedFileSystem.class); Mockito.when(dfs.recoverLease(FILE)). thenReturn(false).thenReturn(false).thenReturn(true); Mockito.when(dfs.isFileClosed(FILE)).thenReturn(true); assertTrue(this.fsHDFSUtils.recoverDFSFileLease(dfs, FILE, HTU.getConfiguration(), reporter)); Mockito.verify(dfs, Mockito.times(2)).recoverLease(FILE); Mockito.verify(dfs, Mockito.times(1)).isFileClosed(FILE); } |
### Question:
OrderedBlob extends OrderedBytesBase<byte[]> { @Override public int encodedLength(byte[] val) { return null == val ? (Order.ASCENDING == order ? 1 : 2) : (Order.ASCENDING == order ? val.length + 1 : val.length + 2); } protected OrderedBlob(Order order); @Override boolean isSkippable(); @Override int encodedLength(byte[] val); @Override Class<byte[]> encodedClass(); @Override byte[] decode(PositionedByteRange src); @Override int encode(PositionedByteRange dst, byte[] val); int encode(PositionedByteRange dst, byte[] val, int voff, int vlen); static final OrderedBlob ASCENDING; static final OrderedBlob DESCENDING; }### Answer:
@Test public void testEncodedLength() { PositionedByteRange buff = new SimplePositionedByteRange(20); for (DataType<byte[]> type : new OrderedBlob[] { OrderedBlob.ASCENDING, OrderedBlob.DESCENDING }) { for (byte[] val : VALUES) { buff.setPosition(0); type.encode(buff, val); assertEquals( "encodedLength does not match actual, " + Bytes.toStringBinary(val), buff.getPosition(), type.encodedLength(val)); } } }
@Test public void testEncodedLength() { PositionedByteRange buff = new SimplePositionedMutableByteRange(20); for (DataType<byte[]> type : new OrderedBlob[] { OrderedBlob.ASCENDING, OrderedBlob.DESCENDING }) { for (byte[] val : VALUES) { buff.setPosition(0); type.encode(buff, val); assertEquals( "encodedLength does not match actual, " + Bytes.toStringBinary(val), buff.getPosition(), type.encodedLength(val)); } } } |
### Question:
OrderedString extends OrderedBytesBase<String> { @Override public int encodedLength(String val) { return null == val ? 1 : val.getBytes(OrderedBytes.UTF8).length + 2; } protected OrderedString(Order order); @Override int encodedLength(String val); @Override Class<String> encodedClass(); @Override String decode(PositionedByteRange src); @Override int encode(PositionedByteRange dst, String val); static final OrderedString ASCENDING; static final OrderedString DESCENDING; }### Answer:
@Test public void testEncodedLength() { PositionedByteRange buff = new SimplePositionedByteRange(20); for (DataType<String> type : new OrderedString[] { OrderedString.ASCENDING, OrderedString.DESCENDING }) { for (String val : VALUES) { buff.setPosition(0); type.encode(buff, val); assertEquals( "encodedLength does not match actual, " + val, buff.getPosition(), type.encodedLength(val)); } } }
@Test public void testEncodedLength() { PositionedByteRange buff = new SimplePositionedMutableByteRange(20); for (DataType<String> type : new OrderedString[] { OrderedString.ASCENDING, OrderedString.DESCENDING }) { for (String val : VALUES) { buff.setPosition(0); type.encode(buff, val); assertEquals( "encodedLength does not match actual, " + val, buff.getPosition(), type.encodedLength(val)); } } } |
### Question:
OrderedBlobVar extends OrderedBytesBase<byte[]> { @Override public int encodedLength(byte[] val) { return null == val ? 1 : OrderedBytes.blobVarEncodedLength(val.length); } protected OrderedBlobVar(Order order); @Override int encodedLength(byte[] val); @Override Class<byte[]> encodedClass(); @Override byte[] decode(PositionedByteRange src); @Override int encode(PositionedByteRange dst, byte[] val); int encode(PositionedByteRange dst, byte[] val, int voff, int vlen); static final OrderedBlobVar ASCENDING; static final OrderedBlobVar DESCENDING; }### Answer:
@Test public void testEncodedLength() { PositionedByteRange buff = new SimplePositionedByteRange(20); for (DataType<byte[]> type : new OrderedBlobVar[] { OrderedBlobVar.ASCENDING, OrderedBlobVar.DESCENDING }) { for (byte[] val : VALUES) { buff.setPosition(0); type.encode(buff, val); assertEquals( "encodedLength does not match actual, " + Bytes.toStringBinary(val), buff.getPosition(), type.encodedLength(val)); } } }
@Test public void testEncodedLength() { PositionedByteRange buff = new SimplePositionedMutableByteRange(20); for (DataType<byte[]> type : new OrderedBlobVar[] { OrderedBlobVar.ASCENDING, OrderedBlobVar.DESCENDING }) { for (byte[] val : VALUES) { buff.setPosition(0); type.encode(buff, val); assertEquals( "encodedLength does not match actual, " + Bytes.toStringBinary(val), buff.getPosition(), type.encodedLength(val)); } } } |
### Question:
TerminatedWrapper implements DataType<T> { @Override public int encode(PositionedByteRange dst, T val) { final int start = dst.getPosition(); int written = wrapped.encode(dst, val); PositionedByteRange b = dst.shallowCopy(); b.setLength(dst.getPosition()); b.setPosition(start); if (-1 != terminatorPosition(b)) { dst.setPosition(start); throw new IllegalArgumentException("Encoded value contains terminator sequence."); } dst.put(term); return written + term.length; } TerminatedWrapper(DataType<T> wrapped, byte[] term); TerminatedWrapper(DataType<T> wrapped, String term); @Override boolean isOrderPreserving(); @Override Order getOrder(); @Override boolean isNullable(); @Override boolean isSkippable(); @Override int encodedLength(T val); @Override Class<T> encodedClass(); @Override int skip(PositionedByteRange src); @Override T decode(PositionedByteRange src); @Override int encode(PositionedByteRange dst, T val); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testEncodedValueContainsTerm() { DataType<byte[]> type = new TerminatedWrapper<byte[]>(new RawBytes(), "foo"); PositionedByteRange buff = new SimplePositionedByteRange(16); type.encode(buff, Bytes.toBytes("hello foobar!")); }
@Test(expected = IllegalArgumentException.class) public void testEncodedValueContainsTerm() { DataType<byte[]> type = new TerminatedWrapper<byte[]>(new RawBytes(), "foo"); PositionedByteRange buff = new SimplePositionedMutableByteRange(16); type.encode(buff, Bytes.toBytes("hello foobar!")); } |
### Question:
TerminatedWrapper implements DataType<T> { @Override public int skip(PositionedByteRange src) { if (wrapped.isSkippable()) { int ret = wrapped.skip(src); src.setPosition(src.getPosition() + term.length); return ret + term.length; } else { final int start = src.getPosition(); int skipped = terminatorPosition(src); if (-1 == skipped) throw new IllegalArgumentException("Terminator sequence not found."); skipped += term.length; src.setPosition(skipped); return skipped - start; } } TerminatedWrapper(DataType<T> wrapped, byte[] term); TerminatedWrapper(DataType<T> wrapped, String term); @Override boolean isOrderPreserving(); @Override Order getOrder(); @Override boolean isNullable(); @Override boolean isSkippable(); @Override int encodedLength(T val); @Override Class<T> encodedClass(); @Override int skip(PositionedByteRange src); @Override T decode(PositionedByteRange src); @Override int encode(PositionedByteRange dst, T val); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testInvalidSkip() { PositionedByteRange buff = new SimplePositionedByteRange(Bytes.toBytes("foo")); DataType<byte[]> type = new TerminatedWrapper<byte[]>(new RawBytes(), new byte[] { 0x00 }); type.skip(buff); }
@Test(expected = IllegalArgumentException.class) public void testInvalidSkip() { PositionedByteRange buff = new SimplePositionedMutableByteRange(Bytes.toBytes("foo")); DataType<byte[]> type = new TerminatedWrapper<byte[]>(new RawBytes(), new byte[] { 0x00 }); type.skip(buff); } |
### Question:
FixedLengthWrapper implements DataType<T> { @Override public T decode(PositionedByteRange src) { if (src.getRemaining() < length) { throw new IllegalArgumentException("Not enough buffer remaining. src.offset: " + src.getOffset() + " src.length: " + src.getLength() + " src.position: " + src.getPosition() + " max length: " + length); } PositionedByteRange b = new SimplePositionedByteRange(length); src.get(b.getBytes()); return base.decode(b); } FixedLengthWrapper(DataType<T> base, int length); int getLength(); @Override boolean isOrderPreserving(); @Override Order getOrder(); @Override boolean isNullable(); @Override boolean isSkippable(); @Override int encodedLength(T val); @Override Class<T> encodedClass(); @Override int skip(PositionedByteRange src); @Override T decode(PositionedByteRange src); @Override int encode(PositionedByteRange dst, T val); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testInsufficientRemainingRead() { PositionedByteRange buff = new SimplePositionedByteRange(0); DataType<byte[]> type = new FixedLengthWrapper<byte[]>(new RawBytes(), 3); type.decode(buff); } |
### Question:
CompatibilitySingletonFactory extends CompatibilityFactory { @SuppressWarnings("unchecked") public static <T> T getInstance(Class<T> klass) { synchronized (SingletonStorage.INSTANCE.lock) { T instance = (T) SingletonStorage.INSTANCE.instances.get(klass); if (instance == null) { try { ServiceLoader<T> loader = ServiceLoader.load(klass); Iterator<T> it = loader.iterator(); instance = it.next(); if (it.hasNext()) { StringBuilder msg = new StringBuilder(); msg.append("ServiceLoader provided more than one implementation for class: ") .append(klass) .append(", using implementation: ").append(instance.getClass()) .append(", other implementations: {"); while (it.hasNext()) { msg.append(it.next()).append(" "); } msg.append("}"); LOG.warn(msg); } } catch (Exception e) { throw new RuntimeException(createExceptionString(klass), e); } catch (Error e) { throw new RuntimeException(createExceptionString(klass), e); } if (instance == null) { throw new RuntimeException(createExceptionString(klass)); } SingletonStorage.INSTANCE.instances.put(klass, instance); } return instance; } } protected CompatibilitySingletonFactory(); @SuppressWarnings("unchecked") static T getInstance(Class<T> klass); }### Answer:
@Test public void testGetInstance() throws Exception { List<TestCompatibilitySingletonFactoryCallable> callables = new ArrayList<TestCompatibilitySingletonFactoryCallable>(ITERATIONS); List<String> resultStrings = new ArrayList<String>(ITERATIONS); for (int i = 0; i < ITERATIONS; i++) { callables.add(new TestCompatibilitySingletonFactoryCallable()); } ExecutorService executorService = Executors.newFixedThreadPool(100); List<Future<String>> futures = executorService.invokeAll(callables); for (Future<String> f : futures) { resultStrings.add(f.get()); } String firstString = resultStrings.get(0); for (String s : resultStrings) { assertEquals(firstString, s); } assertNotEquals(new RandomStringGeneratorImpl().getRandString(), firstString); } |
### Question:
FSTableDescriptors implements TableDescriptors { @VisibleForTesting static int getTableInfoSequenceId(final Path p) { if (p == null) return 0; Matcher m = TABLEINFO_FILE_REGEX.matcher(p.getName()); if (!m.matches()) throw new IllegalArgumentException(p.toString()); String suffix = m.group(2); if (suffix == null || suffix.length() <= 0) return 0; return Integer.parseInt(m.group(2)); } FSTableDescriptors(final Configuration conf); FSTableDescriptors(final FileSystem fs, final Path rootdir); FSTableDescriptors(final FileSystem fs,
final Path rootdir, final boolean fsreadonly); @Override HTableDescriptor get(final TableName tablename); @Override Map<String, HTableDescriptor> getAll(); @Override Map<String, HTableDescriptor> getByNamespace(String name); @Override void add(HTableDescriptor htd); @Override HTableDescriptor remove(final TableName tablename); boolean isTableInfoExists(TableName tableName); static FileStatus getTableInfoPath(FileSystem fs, Path tableDir); static HTableDescriptor getTableDescriptorFromFs(FileSystem fs,
Path hbaseRootDir, TableName tableName); static HTableDescriptor getTableDescriptorFromFs(FileSystem fs, Path tableDir); void deleteTableDescriptorIfExists(TableName tableName); boolean createTableDescriptor(HTableDescriptor htd); boolean createTableDescriptor(HTableDescriptor htd, boolean forceCreation); boolean createTableDescriptorForTableDirectory(Path tableDir,
HTableDescriptor htd, boolean forceCreation); }### Answer:
@Test (expected=IllegalArgumentException.class) public void testRegexAgainstOldStyleTableInfo() { Path p = new Path("/tmp", FSTableDescriptors.TABLEINFO_FILE_PREFIX); int i = FSTableDescriptors.getTableInfoSequenceId(p); assertEquals(0, i); p = new Path("/tmp", "abc"); FSTableDescriptors.getTableInfoSequenceId(p); } |
### Question:
PayloadCarryingRpcController extends TimeLimitedRpcController implements CellScannable { public CellScanner cellScanner() { return cellScanner; } PayloadCarryingRpcController(); PayloadCarryingRpcController(final CellScanner cellScanner); PayloadCarryingRpcController(final List<CellScannable> cellIterables); CellScanner cellScanner(); void setCellScanner(final CellScanner cellScanner); void setPriority(int priority); void setPriority(final TableName tn); int getPriority(); }### Answer:
@Test public void testListOfCellScannerables() throws IOException { List<CellScannable> cells = new ArrayList<CellScannable>(); final int count = 10; for (int i = 0; i < count; i++) { cells.add(createCell(i)); } PayloadCarryingRpcController controller = new PayloadCarryingRpcController(cells); CellScanner cellScanner = controller.cellScanner(); int index = 0; for (; cellScanner.advance(); index++) { Cell cell = cellScanner.current(); byte [] indexBytes = Bytes.toBytes(index); assertTrue("" + index, Bytes.equals(indexBytes, 0, indexBytes.length, cell.getValueArray(), cell.getValueOffset(), cell.getValueLength())); } assertEquals(count, index); } |
### Question:
AsyncProcess { @VisibleForTesting void waitUntilDone() throws InterruptedIOException { waitForMaximumCurrentTasks(0); } AsyncProcess(ClusterConnection hc, Configuration conf, ExecutorService pool,
RpcRetryingCallerFactory rpcCaller, boolean useGlobalErrors, RpcControllerFactory rpcFactory); AsyncRequestFuture submit(TableName tableName, List<? extends Row> rows,
boolean atLeastOne, Batch.Callback<CResult> callback, boolean needResults); AsyncRequestFuture submit(ExecutorService pool, TableName tableName,
List<? extends Row> rows, boolean atLeastOne, Batch.Callback<CResult> callback,
boolean needResults); AsyncRequestFuture submitAll(TableName tableName,
List<? extends Row> rows, Batch.Callback<CResult> callback, Object[] results); AsyncRequestFuture submitAll(ExecutorService pool, TableName tableName,
List<? extends Row> rows, Batch.Callback<CResult> callback, Object[] results); boolean hasError(); RetriesExhaustedWithDetailsException waitForAllPreviousOpsAndReset(
List<Row> failedRows); }### Answer:
@Test public void testHTableFailedPutAndNewPut() throws Exception { HTable ht = new HTable(); MyAsyncProcess ap = new MyAsyncProcess(createHConnection(), conf, true); ht.ap = ap; ht.setAutoFlush(false, true); ht.setWriteBufferSize(0); Put p = createPut(1, false); ht.put(p); ap.waitUntilDone(); p = createPut(1, true); Assert.assertEquals(0, ht.writeAsyncBuffer.size()); try { ht.put(p); Assert.fail(); } catch (RetriesExhaustedException expected) { } Assert.assertEquals("the put should not been inserted.", 0, ht.writeAsyncBuffer.size()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.