method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
OrMessageFilter extends BaseMessageFilter { @Override public boolean apply(Object input) { return orPredicate.apply(input); } OrMessageFilter(MessageFilter... filters); OrMessageFilter(Iterable<? extends MessageFilter> filters); @Override boolean apply(Object input); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void testAllRejectionsLeadToRejection() { List<? extends MessageFilter> filters = ImmutableList.of(getFalseFilter(), getFalseFilter(), getFalseFilter()); OrMessageFilter filter = new OrMessageFilter(filters); assertFalse(filter.apply(DUMMY_INPUT)); }
@Test public void testOneAcceptanceLeadsToAcceptance() { List<? extends MessageFilter> filters = ImmutableList.of(getFalseFilter(), getTrueFilter(), getFalseFilter()); OrMessageFilter filter = new OrMessageFilter(filters); assertTrue(filter.apply(DUMMY_INPUT)); }
@Test public void testOrMessageFilterShortcuts() { MessageFilter falseFilter = getFalseFilter(); MessageFilter trueFilter = getTrueFilter(); List<? extends MessageFilter> filters = ImmutableList.of(trueFilter, falseFilter); assertTrue(new OrMessageFilter(filters).apply(DUMMY_INPUT)); verify(falseFilter, never()).apply(DUMMY_INPUT); } |
### Question:
AlwaysTrueMessageFilter extends BaseMessageFilter { @Override public boolean apply(Object input) { return true; } private AlwaysTrueMessageFilter(); @Override boolean apply(Object input); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static final AlwaysTrueMessageFilter INSTANCE; }### Answer:
@Test public void test() { assertTrue(AlwaysTrueMessageFilter.INSTANCE.apply(DUMMY_INPUT)); } |
### Question:
RoutingKeyFilter implements Filter { @Override public boolean doFilter(MessageContainer message) throws Exception { return filterPattern.matcher(message.getRoutingKey()).find(); } @JsonCreator RoutingKeyFilter(@JsonProperty(JSON_PROPERTY_REGEX) String regex); @JsonProperty(JSON_PROPERTY_REGEX) String getRegex(); @Override boolean doFilter(MessageContainer message); static final String TYPE; static final String JSON_PROPERTY_REGEX; }### Answer:
@Test public void testDoFilter() throws Exception { RoutingKeyFilter filter = new RoutingKeyFilter("(?i)key"); MessageContainer container = makeMessageContainer("routingkEYname", null, null); assertTrue(filter.doFilter(container)); }
@Test public void negativeTest() throws Exception { RoutingKeyFilter filter = new RoutingKeyFilter("nomatch"); MessageContainer container = makeMessageContainer("routingkey", null, null); assertFalse(filter.doFilter(container)); } |
### Question:
XPathFilter implements Filter { @Override public boolean doFilter(MessageContainer message) throws Exception { return filter.apply(converter.convert(message)); } @JsonCreator XPathFilter(
@JsonProperty(JSON_PROPERTY_FILTER) String expression,
@JsonProperty(JSON_PROPERTY_CONVERTER) MessageConverter converter); @Override boolean doFilter(MessageContainer message); @JsonProperty(JSON_PROPERTY_CONVERTER) MessageConverter getConverter(); @JsonProperty(JSON_PROPERTY_FILTER) String getExpression(); static final String TYPE; static final String JSON_PROPERTY_FILTER; static final String JSON_PROPERTY_CONVERTER; }### Answer:
@Test public void testXPathFilterWorksWithMap() throws Exception { String path = " Integer value = 6; XPathFilter filter = new XPathFilter(String.format("xpath(\"%s\") > 5", path), new JsonMapConverter()); assertTrue(filter.doFilter(makeMessageContainer("key", path, value))); }
@Test public void testExistFilter() throws Exception { XPathFilter filter = new XPathFilter("xpath(\"data.fit.sessionId\") exists", new JsonMapConverter()); assertTrue(filter.doFilter(new DefaultMessageContainer(new Message( "routingKey", jsonMapper.writeValueAsBytes( new ImmutableMap.Builder<String, Object>() .put("data.fit.sessionId", "abc") .put("f1", "v1") .build())), jsonMapper))); assertFalse(filter.doFilter(new DefaultMessageContainer(new Message( "routingKey", jsonMapper.writeValueAsBytes( new ImmutableMap.Builder<String, Object>() .put("data.fit.sessionIdABC", "abc") .put("f1", "v1") .build())), jsonMapper))); } |
### Question:
SuroService { @PostConstruct public void start() { try { statusServer.start(); sinkManager.initialStart(); inputManager.initialStart(); } catch (Exception e) { log.error("Exception while starting up server: " + e.getMessage(), e); Throwables.propagate(e); } } @Inject private SuroService(StatusServer statusServer, InputManager inputManager, SinkManager sinkManager); @PostConstruct void start(); @PreDestroy void shutdown(); }### Answer:
@Test public void test() throws Exception { AtomicReference<Injector> injector = new AtomicReference<Injector>(); Properties properties = new Properties(); properties.setProperty(DynamicPropertyRoutingMapConfigurator.ROUTING_MAP_PROPERTY, "{}"); properties.setProperty(DynamicPropertySinkConfigurator.SINK_PROPERTY, "{\n" + " \"default\": {\n" + " \"type\": \"testsuroservice\"\n" + " }\n" + " }\n" + "}"); properties.setProperty(DynamicPropertyInputConfigurator.INPUT_CONFIG_PROPERTY, "[\n" + " {\n" + " \"type\": \"testsuroservice\"\n" + " }\n" + "]"); SuroServer.create(injector, properties, new SuroPlugin() { @Override protected void configure() { addInputType("testsuroservice", TestSuroServiceInput.class); addSinkType("testsuroservice", TestSuroServiceSink.class); } }); injector.get().getInstance(LifecycleManager.class).start(); latch.await(5000, TimeUnit.MILLISECONDS); assertTrue(inputOpened.get()); assertTrue(sinkOpened.get()); } |
### Question:
QueuedSink extends Thread { protected void initialize( String sinkId, MessageQueue4Sink queue4Sink, int batchSize, int batchTimeout, boolean pauseOnLongQueue) { this.sinkId = sinkId; this.queue4Sink = queue4Sink; this.batchSize = batchSize == 0 ? 1000 : batchSize; this.batchTimeout = batchTimeout == 0 ? 1000 : batchTimeout; this.pauseOnLongQueue = pauseOnLongQueue; throughput = new Meter(MonitorConfig.builder(sinkId + "_throughput_meter").build()); } long checkPause(); String getSinkId(); @Override void run(); void close(); @Monitor(name = "numOfPendingMessages", type = DataSourceType.GAUGE) long getNumOfPendingMessages(); static int MAX_PENDING_MESSAGES_TO_PAUSE; }### Answer:
@Test public void synchronizedQueue() throws InterruptedException { final int queueCapacity = 0; final MemoryQueue4Sink queue = new MemoryQueue4Sink(queueCapacity); final AtomicInteger sentCount = new AtomicInteger(); QueuedSink sink = new QueuedSink() { @Override protected void beforePolling() throws IOException { } @Override protected void write(List<Message> msgList) throws IOException { sentCount.addAndGet(msgList.size()); } @Override protected void innerClose() throws IOException { } }; sink.initialize(queue, 100, 1000); sink.start(); int msgCount = 1000; int offered = 0; for (int i = 0; i < msgCount; ++i) { if (queue.offer(new Message("routingKey", ("message" + i).getBytes()))) { offered++; } } assertEquals(msgCount, offered); for (int i = 0; i < 20; ++i) { if (sentCount.get() < offered) { Thread.sleep(500); } } assertEquals(sentCount.get(), offered); } |
### Question:
FileNameFormatter { public static String get(String dir) { StringBuilder sb = new StringBuilder(dir); if (!dir.endsWith("/")) { sb.append('/'); } sb.append(fmt.print(new DateTime())) .append(localHostAddr) .append(new UID().toString()); return sb.toString().replaceAll("[-:]", ""); } static String get(String dir); static String localHostAddr; }### Answer:
@Test public void test() { String name = FileNameFormatter.get("/dir/"); System.out.println(name); assertEquals(name.indexOf("-"), -1); assertEquals(name.indexOf(":"), -1); } |
### Question:
LocalFileSink extends QueuedSink implements Sink { public static String getFileExt(String fileName) { int dotPos = fileName.lastIndexOf('.'); if (dotPos != -1 && dotPos != fileName.length() - 1) { return fileName.substring(dotPos); } else { return null; } } @JsonCreator LocalFileSink(
@JsonProperty("outputDir") String outputDir,
@JsonProperty("writer") FileWriter writer,
@JsonProperty("notice") Notice notice,
@JsonProperty("maxFileSize") long maxFileSize,
@JsonProperty("rotationPeriod") String rotationPeriod,
@JsonProperty("minPercentFreeDisk") int minPercentFreeDisk,
@JsonProperty("queue4Sink") MessageQueue4Sink queue4Sink,
@JsonProperty("batchSize") int batchSize,
@JsonProperty("batchTimeout") int batchTimeout,
@JsonProperty("pauseOnLongQueue") boolean pauseOnLongQueue,
@JacksonInject SpaceChecker spaceChecker); String getOutputDir(); @Override void open(); @Override void writeTo(MessageContainer message); @Override long checkPause(); @Override String recvNotice(); int cleanUp(boolean fetchAll); int cleanUp(String dir, boolean fetchAll); static String getFileExt(String fileName); @Override String getStat(); void deleteFile(String filePath); static final String EMPTY_ROUTING_KEY_REPLACEMENT; static final String TYPE; static final String suffix; static final String done; }### Answer:
@Test public void testGetFileExt() { assertEquals(LocalFileSink.getFileExt("abc.done"), ".done"); assertNull(LocalFileSink.getFileExt("abcdone")); assertNull(LocalFileSink.getFileExt("abcdone.")); } |
### Question:
PathValueMessageFilter extends BaseMessageFilter { @SuppressWarnings("unchecked") @Override public boolean apply(Object input) { JXPathContext jxpath = JXPathContext.newContext(input); jxpath.setLenient(true); Object value = jxpath.getValue(xpath); return predicate.apply(value); } PathValueMessageFilter(String path, ValuePredicate predicate); @SuppressWarnings("unchecked") @Override boolean apply(Object input); String getXpath(); ValuePredicate getPredicate(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testPositiveSelection() { MockRequestTrace requestTrace = Mockito.mock(MockRequestTrace.class); when(requestTrace.getClientInfoHostName()).thenReturn("localhost"); Map<String, Object> clientInfoMap = Maps.newHashMap(); clientInfoMap.put("clientName", "client"); clientInfoMap.put("clientId", (long) 10); when(requestTrace.getClientInfoMap()).thenReturn(clientInfoMap); MessageFilter filter = new PathValueMessageFilter(" assertTrue("Filter should return true as the client ID is 10, greater than 5", filter.apply(requestTrace)); filter = new PathValueMessageFilter(" assertTrue("Filter should return true as client name is 'client'", filter.apply(requestTrace)); filter = new PathValueMessageFilter(" assertTrue("Filter should return tre as clientInfoHostName is localhost", filter.apply(requestTrace)); }
@Test public void testNonExistentValueShouldBeFiltered(){ MockRequestTrace requestTrace = Mockito.mock(MockRequestTrace.class); MessageFilter filter = new PathValueMessageFilter(" assertFalse(filter.apply(requestTrace)); }
@Test public void testNullValueCanBeAccepted(){ MockRequestTrace requestTrace = Mockito.mock(MockRequestTrace.class); MessageFilter filter = new PathValueMessageFilter(" assertTrue(filter.apply(requestTrace)); } |
### Question:
IndexSuffixFormatter { public String format(IndexInfo info) { return formatter.apply(info); } @JsonCreator IndexSuffixFormatter(
@JsonProperty("type") String type,
@JsonProperty("properties") Properties props); String format(IndexInfo info); }### Answer:
@Test public void shouldNullTypeReturnsEmptyString() { IndexSuffixFormatter formatter = new IndexSuffixFormatter(null, null); assertEquals(formatter.format(any(IndexInfo.class)), ""); }
@Test public void shouldDateTypeReturnsCorrectOne() { System.setProperty("user.timezone", "GMT"); Properties props = new Properties(); props.put("dateFormat", "YYYYMMdd"); DateTime dt = new DateTime("2014-10-12T00:00:00.000Z"); IndexSuffixFormatter formatter = new IndexSuffixFormatter("date", props); IndexInfo info = mock(IndexInfo.class); doReturn(dt.getMillis()).when(info).getTimestamp(); assertEquals(formatter.format(info), "20141012"); }
@Test public void testWeeklyRepresentation() { System.setProperty("user.timezone", "GMT"); Properties props = new Properties(); props.put("dateFormat", "YYYYMM_ww"); DateTime dt = new DateTime("2014-10-12T00:00:00.000Z"); IndexSuffixFormatter formatter = new IndexSuffixFormatter("date", props); IndexInfo info = mock(IndexInfo.class); doReturn(dt.getMillis()).when(info).getTimestamp(); assertEquals(formatter.format(info), "201410_41"); } |
### Question:
SuroPing extends AbstractLoadBalancerPing { public boolean isAlive(Server server) { TSocket socket = null; TFramedTransport transport = null; try { socket = new TSocket(server.getHost(), server.getPort(), 2000); socket.getSocket().setTcpNoDelay(true); socket.getSocket().setKeepAlive(true); socket.getSocket().setSoLinger(true, 0); transport = new TFramedTransport(socket); transport.open(); return true; } catch (TTransportException e) { logger.warn("Ping {}", e.getMessage()); return false; } catch (SocketException e) { logger.warn("Ping {}", e.getMessage()); return false; } finally { close(transport); close(socket); } } SuroPing(); boolean isAlive(Server server); @Override void initWithNiwsConfig(IClientConfig clientConfig); }### Answer:
@Test public void pingTest() throws Exception { final SuroServer4Test server4Test = new SuroServer4Test(); server4Test.start(); SuroPing ping = new SuroPing(); Server server = new Server("localhost", server4Test.getPort()); assertEquals(true, ping.isAlive(server)); server4Test.shutdown(); }
@Test public void pingFailTest() throws Exception { SuroPing ping = new SuroPing(); Server server = new Server("localhost", 7901); assertEquals(false, ping.isAlive(server)); } |
### Question:
GrantAcl { public GrantAcl(RestS3Service s3Service, String s3Acl, int s3AclRetries) { this.s3Service = s3Service; this.s3Acl = s3Acl; this.s3AclRetries = s3AclRetries; } GrantAcl(RestS3Service s3Service, String s3Acl, int s3AclRetries); boolean grantAcl(S3Object object); }### Answer:
@Test public void test() throws Exception { RestS3Service s3Service = mock(RestS3Service.class); AccessControlList acl = new AccessControlList(); doReturn(acl).when(s3Service).getObjectAcl("bucket", "key"); doNothing().when(s3Service).putObjectAcl("bucket", "key", acl); GrantAcl grantAcl = new GrantAcl(s3Service, "1,2,3", 1); S3Object obj = new S3Object("key"); obj.setBucketName("bucket"); obj.setAcl(GSAccessControlList.REST_CANNED_BUCKET_OWNER_FULL_CONTROL); assertTrue(grantAcl.grantAcl(obj)); Set<GrantAndPermission> grants = new HashSet<GrantAndPermission>(Arrays.asList(acl.getGrantAndPermissions())); assertEquals(grants.size(), 3); Set<GrantAndPermission> grantSet = new HashSet<GrantAndPermission>(); for (int i = 1; i <= 3; ++i) { grantSet.add(new GrantAndPermission(new CanonicalGrantee(Integer.toString(i)), Permission.PERMISSION_READ)); } } |
### Question:
NullValuePredicate implements ValuePredicate { @Override public boolean apply(final Object input) { return input == null; } private NullValuePredicate(); @Override boolean apply(final Object input); @Override String toString(); @Override final int hashCode(); @Override final boolean equals(Object obj); static final NullValuePredicate INSTANCE; }### Answer:
@Test public void testNullIsAccepted() { assertTrue(NullValuePredicate.INSTANCE.apply(null)); }
@Test public void testNonNullIsRejected() { assertFalse(NullValuePredicate.INSTANCE.apply(new Object())); } |
### Question:
StringValuePredicate implements ValuePredicate<String> { @Override public boolean apply(@Nullable String input) { return Objects.equal(value, input); } StringValuePredicate(@Nullable String value); @Override boolean apply(@Nullable String input); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer:
@Test public void testValueComparison() throws Exception { Object[][] inputs = { {"abc", "abc", true}, {"", "", true}, {"AB", "A", false}, {null, null, true}, {null, "", false}, {"", null, false} }; for(Object[] input : inputs){ String value = (String)input[0]; String inputValue = (String)input[1]; boolean expected = ((Boolean)input[2]).booleanValue(); StringValuePredicate pred = new StringValuePredicate(value); assertEquals(String.format("Given value = %s, and input = %s", value, inputValue), expected, pred.apply(inputValue)); } } |
### Question:
LocaleResolver { DefaultResolvedLocalePair resolveDefault() { MatchingLocales matchingPair = matchingAlgorithm.findDefaultMatch(supportedLocales, systemLocales); return matchingPair != null ? new DefaultResolvedLocalePair(matchingPair.getSupportedLocale(), matchingPair.getPreferredLocale(preference)) : new DefaultResolvedLocalePair(supportedLocales.get(0), supportedLocales.get(0)); } LocaleResolver(List<Locale> supportedLocales,
List<Locale> systemLocales,
MatchingAlgorithm matchingAlgorithm,
LocalePreference preference); }### Answer:
@Test public void ShouldResolveFirstSupportedLocaleAsDefault_WhenResolveDefaultLocale_GivenNonMatchingLocales() { LocaleResolver sut = new LocaleResolver( Arrays.asList(LOCALE_ES_ES, LOCALE_IT_IT), Arrays.asList(LOCALE_EN_US, LOCALE_FR_FR), new LanguageMatchingAlgorithm(), ANY_PREFERENCE ); DefaultResolvedLocalePair defaultResolvedLocalePair = sut.resolveDefault(); Assert.assertEquals(LOCALE_ES_ES, defaultResolvedLocalePair.getResolvedLocale()); } |
### Question:
LocaleChangerDelegate { void setLocale(Locale supportedLocale) { try { currentLocale = resolver.resolve(supportedLocale); persistor.save(supportedLocale); appLocaleChanger.change(currentLocale); } catch (UnsupportedLocaleException e) { throw new IllegalArgumentException(e); } } LocaleChangerDelegate(LocalePersistor persistor,
LocaleResolver resolver,
AppLocaleChanger appLocaleChanger); }### Answer:
@Test public void ShouldPersistLocaleWithSupportedLocale_WhenChanged_GivenSupportedLocale() { sut.setLocale(ANY_LOCALE); verify(localePersistor).save(ANY_LOCALE); }
@Test public void ShouldChangeAppLocaleWithAMatchingLocale_WhenChanged_GivenSupportedLocale() throws UnsupportedLocaleException { doReturn(ANY_LOCALE).when(localeResolver).resolve(ANY_LOCALE); sut.setLocale(ANY_LOCALE); verify(appLocaleChanger).change(ANY_LOCALE); }
@Test(expected = IllegalArgumentException.class) public void ShouldThrowIllegalArgumentException_WhenChanged_GivenNotSupportedLocale() throws UnsupportedLocaleException { doThrow(IllegalArgumentException.class).when(localeResolver).resolve(ANY_LOCALE); sut.setLocale(ANY_LOCALE); } |
### Question:
LocaleChangerDelegate { Locale getLocale() { return persistor.load(); } LocaleChangerDelegate(LocalePersistor persistor,
LocaleResolver resolver,
AppLocaleChanger appLocaleChanger); }### Answer:
@Test public void ShouldLoadPersistedLocale_WhenGetCurrentSupportedLocale() { doReturn(ANY_LOCALE).when(localePersistor).load(); Locale currentSupportedLocale = sut.getLocale(); assertEquals(ANY_LOCALE, currentSupportedLocale); } |
### Question:
LibraryDBDao implements Serializable { public void destoryDB() { mDbOpenHelper = null; DataBaseOpenHelper.clearInstance(); } LibraryDBDao(Context context); void destoryDB(); boolean addBook(Book book); List<Book> queryAllBookList(); void updateBookInfo(String id, Book book); List<Book> searchBooks(String columnName, String columnValue); List<Book> searchBooks(HashMap<String, String> map); void removeBook(int id); void delAllData(); String getNotOccupiedKeyId(); static final int SEARCHTYPE_ID; }### Answer:
@Test public void testSaveAndQueryAllBook() throws Exception { traverseData(); mDao.destoryDB(); } |
### Question:
BatchEnvironment extends org.glassfish.rmic.tools.javac.BatchEnvironment { public static ClassPath createClassPath(String classPathString, String sysClassPathString) { Path path = new Path(); if (sysClassPathString == null) { sysClassPathString = System.getProperty("sun.boot.class.path"); } if (sysClassPathString != null) { path.addFiles(sysClassPathString); } path.expandJarClassPaths(true); path.emptyPathDefault("."); if (classPathString == null) { classPathString = System.getProperty("env.class.path"); if (classPathString == null) { classPathString = "."; } } path.addFiles(classPathString); return new ClassPath(path.toArray(new String[path.size()])); } BatchEnvironment(OutputStream out, ClassPath path, File destinationDir); static ClassPath createClassPath(String classPathString, String sysClassPathString); File getDestinationDir(); ClassPath getClassPath(); void addGeneratedFile(File file); void shutdown(); String errorString(String err,
Object arg0, Object arg1, Object arg2); void reset(); }### Answer:
@Test public void createdClassPathString_usesPathSeparator() throws Exception { String systemPath = "./jdk/jre/lib/rt.jar"; String classPath = "./user.jar" + File.pathSeparator + "./user2.jar" + File.pathSeparator + "./user3.jar"; assertThat(BatchEnvironment.createClassPath(classPath, systemPath).toString().split(File.pathSeparator), arrayWithSize(4)); } |
### Question:
TypeFactory { static Type createType(String descriptor) { return toRmicType(org.objectweb.asm.Type.getType(descriptor)); } }### Answer:
@Test public void constructMultiDimensionalArrayType() throws Exception { assertThat(TypeFactory.createType("[[I"), equalTo(Type.tArray(Type.tArray(Type.tInt)))); } |
### Question:
ClientRequestDispatcherImpl implements
ClientRequestDispatcher { @Subcontract public CDRInputObject marshalingComplete(java.lang.Object self, CDROutputObject outputObject) throws ApplicationException, org.omg.CORBA.portable.RemarshalException { MessageMediator messageMediator = outputObject.getMessageMediator(); ORB orb = messageMediator.getBroker(); operationAndId(messageMediator.getOperationName(), messageMediator.getRequestId() ); try { exit_clientEncoding(); enter_clientTransportAndWait(); CDRInputObject inputObject = null ; try { inputObject = marshalingComplete1(orb, messageMediator); } finally { exit_clientTransportAndWait(); } return processResponse(orb, messageMediator, inputObject); } finally { enter_clientDecoding() ; } } @Subcontract CDROutputObject beginRequest(Object self, String opName,
boolean isOneWay, ContactInfo contactInfo); @Subcontract CDRInputObject marshalingComplete(java.lang.Object self,
CDROutputObject outputObject); @Subcontract CDRInputObject marshalingComplete1(
ORB orb, MessageMediator messageMediator); @Subcontract void endRequest(ORB orb, Object self, CDRInputObject inputObject); }### Answer:
@Test(expected = RemarshalException.class) public void whenPIHandleReturnsRemarshalException_throwIt() throws Exception { orb.setPiEndingPointException(new RemarshalException()); impl.marshalingComplete(null, outputObject); } |
### Question:
StubInvocationHandlerImpl implements LinkedInvocationHandler { public Object invoke( Object proxy, final Method method, Object[] args ) throws Throwable { Delegate delegate = null ; try { delegate = StubAdapter.getDelegate( stub ) ; } catch (SystemException ex) { throw Util.getInstance().mapSystemException(ex) ; } org.omg.CORBA.ORB delORB = delegate.orb( stub ) ; if (delORB instanceof ORB) { ORB orb = (ORB)delORB ; InvocationInterceptor interceptor = orb.getInvocationInterceptor() ; try { interceptor.preInvoke() ; } catch (Exception exc) { } try { return privateInvoke( delegate, proxy, method, args ) ; } finally { try { interceptor.postInvoke() ; } catch (Exception exc) { } } } else { return privateInvoke( delegate, proxy, method, args ) ; } } StubInvocationHandlerImpl( PresentationManager pm,
PresentationManager.ClassData classData, org.omg.CORBA.Object stub ); void setProxy( Proxy self ); Proxy getProxy(); Object invoke( Object proxy, final Method method,
Object[] args ); }### Answer:
@Test public void whenColocatedCallThrowsException_exceptionHasStackTrace() throws Throwable { try { handler.invoke(calledObject, throwExceptionMethod, new Object[0]); } catch (TestException exception) { assertThat(exception.getStackTrace(), not(emptyArray())); } } |
### Question:
SelectorImpl extends
Thread implements
com.sun.corba.ee.spi.transport.Selector { @Transport public void registerForEvent(EventHandler eventHandler) { if (isClosed()) { closedEventHandler(); return; } if (eventHandler.shouldUseSelectThreadToWait()) { synchronized (deferredRegistrations) { deferredRegistrations.add(eventHandler); } startSelector(); selector.wakeup(); return; } switch (eventHandler.getInterestOps()) { case SelectionKey.OP_ACCEPT : createListenerThread(eventHandler); break; case SelectionKey.OP_READ : createReaderThread(eventHandler); break; default: defaultCaseForEventHandler(); throw new RuntimeException( "SelectorImpl.registerForEvent: unknown interest ops"); } } SelectorImpl(ORB orb); SelectorImpl(ORB orb, Timer timer); void setTimeout(long timeout); @ManagedAttribute @Description( "The selector timeout" ) long getTimeout(); @Transport void registerInterestOps(EventHandler eventHandler); @Transport void registerForEvent(EventHandler eventHandler); @Transport void unregisterForEvent(EventHandler eventHandler); @Transport void close(); @Transport @Override void run(); }### Answer:
@Test public void whenRegisteringAcceptEventWithoutSelectThread_listenerThreadIsCreated() { eventHandler.setUseSelectThreadToWait(false); eventHandler.setInterestOps(SelectionKey.OP_ACCEPT); selector.registerForEvent(eventHandler); assertTrue(getWorkQueue().remove() instanceof ListenerThreadImpl); }
@Test public void whenRegisteringReadEventWithoutSelectThread_readerThreadIsCreated() { eventHandler.setUseSelectThreadToWait(false); eventHandler.setInterestOps(SelectionKey.OP_READ); selector.registerForEvent(eventHandler); assertTrue(getWorkQueue().remove() instanceof ReaderThreadImpl); } |
### Question:
IIOPProfileImpl extends IdentifiableBase implements IIOPProfile { @IsLocal public synchronized boolean isLocal() { if (!checkedIsLocal) { checkedIsLocal = true ; if (isForeignObject()) return false; final int port = proftemp.getPrimaryAddress().getPort(); final String host = proftemp.getPrimaryAddress().getHost() ; final int scid = oktemp.getSubcontractId() ; final int sid = oktemp.getServerId() ; computingIsLocal( host, scid, sid, port ) ; final boolean isLocalHost = orb.isLocalHost( host ) ; final boolean isLocalServerId = (sid == -1) || orb.isLocalServerId( scid, sid ) ; final boolean isLocalServerPort = orb.getLegacyServerSocketManager().legacyIsLocalServerPort( port ) ; isLocalResults( isLocalHost, isLocalServerId, isLocalServerPort ) ; cachedIsLocal = isLocalHost && isLocalServerId && isLocalServerPort ; } return cachedIsLocal ; } private IIOPProfileImpl( ORB orb ); IIOPProfileImpl( ORB orb, ObjectKeyTemplate oktemp, ObjectId oid,
IIOPProfileTemplate proftemp ); IIOPProfileImpl( InputStream is ); IIOPProfileImpl( ORB orb, org.omg.IOP.TaggedProfile profile); String toString(); @Override boolean equals( Object obj ); @Override int hashCode(); ObjectId getObjectId(); TaggedProfileTemplate getTaggedProfileTemplate(); ObjectKeyTemplate getObjectKeyTemplate(); void writeContents(OutputStream os); int getId(); boolean isEquivalent( TaggedProfile prof ); synchronized ObjectKey getObjectKey(); org.omg.IOP.TaggedProfile getIOPProfile(); synchronized String getCodebase(); ORBVersion getORBVersion(); @IsLocal synchronized boolean isLocal(); @IsLocal java.lang.Object getServant(); synchronized GIOPVersion getGIOPVersion(); void makeImmutable(); }### Answer:
@Test public void whenForeignProfileOrbVersion_isLocalReturnsFalse() throws Exception { setOrbVersion(ORBVersionImpl.FOREIGN); assertThat(iiopProfile.isLocal(), is(false)); } |
### Question:
PresentationDefaults { synchronized static PresentationManager.StubFactoryFactory getDynamicStubFactoryFactory() { if (dynamicImpl == null) dynamicImpl = new StubFactoryFactoryCodegenImpl(); return dynamicImpl ; } private PresentationDefaults(); synchronized static PresentationManager.StubFactoryFactory getStaticStubFactoryFactory(); static PresentationManager.StubFactory makeStaticStubFactory(
final Class stubClass ); static InvocationInterceptor getNullInvocationInterceptor(); static boolean inAppServer(); static PresentationManagerImpl makeOrbPresentationManager(); }### Answer:
@Test public void dynamicStubFactory_createsDynamicStubs() throws Exception { assertThat(PresentationDefaults.getDynamicStubFactoryFactory().createsDynamicStubs(), is(true)); } |
### Question:
PresentationDefaults { public synchronized static PresentationManager.StubFactoryFactory getStaticStubFactoryFactory() { if (staticImpl == null) staticImpl = new StubFactoryFactoryStaticImpl(); return staticImpl; } private PresentationDefaults(); synchronized static PresentationManager.StubFactoryFactory getStaticStubFactoryFactory(); static PresentationManager.StubFactory makeStaticStubFactory(
final Class stubClass ); static InvocationInterceptor getNullInvocationInterceptor(); static boolean inAppServer(); static PresentationManagerImpl makeOrbPresentationManager(); }### Answer:
@Test public void staticStubFactory_doesNotCreateDynamicStubs() throws Exception { assertThat(PresentationDefaults.getStaticStubFactoryFactory().createsDynamicStubs(), is(false)); } |
### Question:
PresentationDefaults { public static PresentationManagerImpl makeOrbPresentationManager() { final boolean useDynamicStub = getBooleanPropertyValue( ORBConstants.USE_DYNAMIC_STUB_PROPERTY, inAppServer() ) ; final boolean debug = getBooleanPropertyValue( ORBConstants.DEBUG_DYNAMIC_STUB, false ) ; final PresentationManagerImpl result = new PresentationManagerImpl( useDynamicStub ) ; result.setStaticStubFactoryFactory(PresentationDefaults.getStaticStubFactoryFactory()); result.setDynamicStubFactoryFactory(PresentationDefaults.getDynamicStubFactoryFactory()); if (debug) { result.enableDebug( System.out ) ; } return result ; } private PresentationDefaults(); synchronized static PresentationManager.StubFactoryFactory getStaticStubFactoryFactory(); static PresentationManager.StubFactory makeStaticStubFactory(
final Class stubClass ); static InvocationInterceptor getNullInvocationInterceptor(); static boolean inAppServer(); static PresentationManagerImpl makeOrbPresentationManager(); }### Answer:
@Test public void defaultOrbPresentationManager_createsDynamicStubs() throws Exception { assertThat(PresentationDefaults.makeOrbPresentationManager().useDynamicStubs(), is(true)); }
@Test public void whenSystemPropertyFalse_presentationManagerCreatesStaticStubs() throws Exception { mementos.add(SystemPropertySupport.install(ORBConstants.USE_DYNAMIC_STUB_PROPERTY, "false")); assertThat(PresentationDefaults.makeOrbPresentationManager().useDynamicStubs(), is(false)); } |
### Question:
Util { public static String getVersion () { return getVersion (DEFAULT_MESSAGE_RESOURCE); } static String getVersion(); static boolean isAttribute(String name, Hashtable symbolTable); static boolean isConst(String name, Hashtable symbolTable); static boolean isEnum(String name, Hashtable symbolTable); static boolean isException(String name, Hashtable symbolTable); static boolean isInterface(String name, Hashtable symbolTable); static boolean isMethod(String name, Hashtable symbolTable); static boolean isModule(String name, Hashtable symbolTable); static boolean isParameter(String name, Hashtable symbolTable); static boolean isPrimitive(String name, Hashtable symbolTable); static boolean isSequence(String name, Hashtable symbolTable); static boolean isStruct(String name, Hashtable symbolTable); static boolean isString(String name, Hashtable symbolTable); static boolean isTypedef(String name, Hashtable symbolTable); static boolean isUnion(String name, Hashtable symbolTable); static String getMessage(String key); static String getMessage(String key, String fill); static String getMessage(String key, String[] fill); static void registerMessageResource(String resourceName); static String capitalize(String lc); static String getAbsolutePath(String filename, Vector includePaths); static float absDelta(float f1, float f2); }### Answer:
@Test public void readVersionFromDefaultPropertyFile() throws Exception { assertThat(Util.getVersion(), containsString("4.02")); }
@Test public void readVersionFromUnnamedPropertyFile() throws Exception { assertThat(Util.getVersion(""), containsString("4.02")); } |
### Question:
Util { public static String getMessage (String key) { if (messages == null) readMessages (); String message = messages.getProperty (key); if (message == null) message = getDefaultMessage (key); return message; } static String getVersion(); static boolean isAttribute(String name, Hashtable symbolTable); static boolean isConst(String name, Hashtable symbolTable); static boolean isEnum(String name, Hashtable symbolTable); static boolean isException(String name, Hashtable symbolTable); static boolean isInterface(String name, Hashtable symbolTable); static boolean isMethod(String name, Hashtable symbolTable); static boolean isModule(String name, Hashtable symbolTable); static boolean isParameter(String name, Hashtable symbolTable); static boolean isPrimitive(String name, Hashtable symbolTable); static boolean isSequence(String name, Hashtable symbolTable); static boolean isStruct(String name, Hashtable symbolTable); static boolean isString(String name, Hashtable symbolTable); static boolean isTypedef(String name, Hashtable symbolTable); static boolean isUnion(String name, Hashtable symbolTable); static String getMessage(String key); static String getMessage(String key, String fill); static String getMessage(String key, String[] fill); static void registerMessageResource(String resourceName); static String capitalize(String lc); static String getAbsolutePath(String filename, Vector includePaths); static float absDelta(float f1, float f2); }### Answer:
@Test public void retrieveMessage() throws Exception { assertThat(Util.getMessage("EvaluationException.not"), equalTo("bitwise not")); }
@Test public void substituteSingleParamMessage() throws Exception { assertThat(Util.getMessage("InvalidArgument.1", "zork"), equalTo("Invalid argument: zork.")); }
@Test public void substituteMultiParamMessage() throws Exception { assertThat(Util.getMessage("GenFileStream.1", new String[] {"zork", "foo"}), equalTo("zork could not be generated: foo")); } |
### Question:
AsmClassFactory implements ClassDefinitionFactory { static int getLatestVersion() { try { int latest = 0; for (Field field : Opcodes.class.getDeclaredFields()) { if (field.getName().startsWith("ASM") && field.getType().equals(int.class)) { latest = Math.max(latest, field.getInt(Opcodes.class)); } } return latest; } catch (IllegalAccessException e) { return Opcodes.ASM6; } } AsmClassFactory(); @Override ClassDefinition loadDefinition(InputStream is, Environment env); }### Answer:
@Test public void canRetrieveLatestAsmVersion() { assertThat(AsmClassFactory.getLatestVersion(), equalTo(Opcodes.ASM6)); } |
### Question:
AdhocProject implements Project,
FileOwnerQueryImplementation, ProjectConfiguration,
ProjectActionPerformer, ActionProvider, LogicalViewProvider { @Override public FileObject getProjectDirectory() { return dir; } AdhocProject(FileObject dir, ProjectState state); @Override FileObject getProjectDirectory(); @Override Lookup getLookup(); @Override String getDisplayName(); void addPropertyChangeListener(PropertyChangeListener pl); void removePropertyChangeListener(PropertyChangeListener pl); @Override boolean enable(Project prjct); @Override void perform(Project prjct); @Override String[] getSupportedActions(); @Override void invokeAction(String string, Lookup lkp); @Override boolean isActionEnabled(String string, Lookup lkp); void setEncoding(Charset charset); Charset getEncoding(); List<Favorite> favorites(); Preferences forFile(FileObject fo, String string); Preferences forDocument(Document dcmnt, String string); @Override Project getOwner(URI uri); @Override Project getOwner(FileObject fo); int getMaxFavorites(); int getFavoriteUsageCount(); void setFavoriteUsageCount(int val); void setMaxFavorites(int val); void setDisplayName(String name); @Override Node createLogicalView(); @Override Node findPath(Node node, Object o); static final String CUSTOMIZE_COMMAND; static final String TYPE_NAME; }### Answer:
@Test public void testGetProjectDirectory() { assertTrue(true); } |
### Question:
AdhocProject implements Project,
FileOwnerQueryImplementation, ProjectConfiguration,
ProjectActionPerformer, ActionProvider, LogicalViewProvider { @Override public String getDisplayName() { return info.getDisplayName(); } AdhocProject(FileObject dir, ProjectState state); @Override FileObject getProjectDirectory(); @Override Lookup getLookup(); @Override String getDisplayName(); void addPropertyChangeListener(PropertyChangeListener pl); void removePropertyChangeListener(PropertyChangeListener pl); @Override boolean enable(Project prjct); @Override void perform(Project prjct); @Override String[] getSupportedActions(); @Override void invokeAction(String string, Lookup lkp); @Override boolean isActionEnabled(String string, Lookup lkp); void setEncoding(Charset charset); Charset getEncoding(); List<Favorite> favorites(); Preferences forFile(FileObject fo, String string); Preferences forDocument(Document dcmnt, String string); @Override Project getOwner(URI uri); @Override Project getOwner(FileObject fo); int getMaxFavorites(); int getFavoriteUsageCount(); void setFavoriteUsageCount(int val); void setMaxFavorites(int val); void setDisplayName(String name); @Override Node createLogicalView(); @Override Node findPath(Node node, Object o); static final String CUSTOMIZE_COMMAND; static final String TYPE_NAME; }### Answer:
@Test public void testGetDisplayName() { assertEquals(name, project.getDisplayName()); } |
### Question:
AdhocProject implements Project,
FileOwnerQueryImplementation, ProjectConfiguration,
ProjectActionPerformer, ActionProvider, LogicalViewProvider { public Charset getEncoding() { try { Preferences p = preferences(false); if (p != null) { String name = p.get("charset", "UTF-8"); return Charset.forName(name); } } catch (BackingStoreException ex) { Exceptions.printStackTrace(ex); } return Charset.forName("UTF-8"); } AdhocProject(FileObject dir, ProjectState state); @Override FileObject getProjectDirectory(); @Override Lookup getLookup(); @Override String getDisplayName(); void addPropertyChangeListener(PropertyChangeListener pl); void removePropertyChangeListener(PropertyChangeListener pl); @Override boolean enable(Project prjct); @Override void perform(Project prjct); @Override String[] getSupportedActions(); @Override void invokeAction(String string, Lookup lkp); @Override boolean isActionEnabled(String string, Lookup lkp); void setEncoding(Charset charset); Charset getEncoding(); List<Favorite> favorites(); Preferences forFile(FileObject fo, String string); Preferences forDocument(Document dcmnt, String string); @Override Project getOwner(URI uri); @Override Project getOwner(FileObject fo); int getMaxFavorites(); int getFavoriteUsageCount(); void setFavoriteUsageCount(int val); void setMaxFavorites(int val); void setDisplayName(String name); @Override Node createLogicalView(); @Override Node findPath(Node node, Object o); static final String CUSTOMIZE_COMMAND; static final String TYPE_NAME; }### Answer:
@Test public void testGetEncoding() { Charset ascii = Charset.forName("US-ASCII"); Charset utf8 = Charset.forName("UTF-8"); assertEquals(utf8, project.getEncoding()); project.setEncoding(ascii); assertEquals(ascii, project.getEncoding()); } |
### Question:
UserController { @GetMapping("/{userId}") public UserDto getUser(@PathVariable long userId) throws ApplicationException { User user = userService.getUser(userId); return userMapper.toUserDto(user); } UserController(UserMapper userMapper, UserService userService); @GetMapping("/{userId}") UserDto getUser(@PathVariable long userId); @GetMapping("/") List<User> getUsers(); @PostMapping void createUser(@RequestBody @Validated UserDto userDto); @DeleteMapping("/{userId}") void deleteUser(@PathVariable long userId); @PutMapping UserDto updateUser(@RequestBody UserDto userDto); @PutMapping("{userId}/confirm_email/{token}") void confirmEmail(@PathVariable Long userId, @PathVariable String token); @PutMapping("{userId}/confirm_password_reset/{token}") void confirmPasswordReset(@PathVariable Long userId, @PathVariable String token); }### Answer:
@Test public void testGetUser() throws Exception { mockMvc.perform(MockMvcRequestBuilders.get("/users/1").contentType(APPLICATION_JSON)) .andExpect(MockMvcResultMatchers.status().isOk()) .andExpect(MockMvcResultMatchers.jsonPath("id", Matchers.is(1))) .andExpect(MockMvcResultMatchers.jsonPath("screenName", Matchers.is("test"))).andExpect( MockMvcResultMatchers.jsonPath("contactData.email", Matchers.is("[email protected]"))) .andDo(MockMvcResultHandlers.print()); verify(userService).getUser(1L); verifyNoMoreInteractions(userService); }
@Test public void testGetUser_notFound() throws Exception { mockMvc.perform(MockMvcRequestBuilders.get("/users/0").contentType(APPLICATION_JSON)) .andExpect(MockMvcResultMatchers.status().isNotFound()) .andExpect(MockMvcResultMatchers.jsonPath("statusCode", Matchers.is(404))) .andExpect(MockMvcResultMatchers.jsonPath("reasonPhrase", Matchers.is("Not Found"))) .andDo(MockMvcResultHandlers.print()); verify(userService).getUser(0L); verifyNoMoreInteractions(userService); } |
### Question:
IdentityGenerator { public static long generate() { return generate(DEFAULT_SHARD_ID); } private IdentityGenerator(); static Instant extractInstant(long id); static byte extractShardId(long id); static long generate(); static long generate(byte shardId); static final byte DEFAULT_SHARD_ID; static final Instant EPOCH; }### Answer:
@Test @Ignore public void testCollision() throws Exception { ExecutorService executorService = Executors.newFixedThreadPool(100); final int NUM_IDS = 1_000_000; final ConcurrentMap<Long, AtomicInteger> collisionMap = new ConcurrentHashMap<Long, AtomicInteger>(NUM_IDS); for (int i = 0; i < NUM_IDS; i++) { executorService.submit(new Runnable() { @Override public void run() { long id = IdentityGenerator.generate(); AtomicInteger collisionCount = collisionMap.get(id); if (collisionCount == null) { collisionCount = new AtomicInteger(0); AtomicInteger oldCollisionCount = collisionMap.putIfAbsent(id, collisionCount); if (oldCollisionCount != null) { collisionCount.addAndGet(oldCollisionCount.get()); } } else { int currentCollisionCount = collisionCount.incrementAndGet(); LOGGER.warn("{} collision(s) on ID {}", currentCollisionCount, id); } } }); } executorService.shutdown(); executorService.awaitTermination(30, TimeUnit.SECONDS); double uniquePercent = collisionMap.size() * 100.0 / NUM_IDS; LOGGER.info("{}% of all IDs are unique.", uniquePercent); assertTrue(uniquePercent > 99.9); }
@Test public void testGenerate() { long id = IdentityGenerator.generate(); assertNotEquals(0, id); System.out.println(id); } |
### Question:
IdentityGenerator { static long doGenerate(byte shardId, long time, int serial) { return (shardId & 0x7fL) << 56 | (time & 0xffffffffffL) << 16 | (serial & 0xffff); } private IdentityGenerator(); static Instant extractInstant(long id); static byte extractShardId(long id); static long generate(); static long generate(byte shardId); static final byte DEFAULT_SHARD_ID; static final Instant EPOCH; }### Answer:
@Test public void testDoGenerate_withSerial() { long id = IdentityGenerator.doGenerate((byte) 0, 0L, 1); assertEquals(1L, id); }
@Test public void testDoGenerate_withShardId() { long id = IdentityGenerator.doGenerate((byte) 1, 0L, 0); assertEquals((long) 1L << 56, id); }
@Test public void testDoGenerate_withTime() { long id = IdentityGenerator.doGenerate((byte) 0, 1L, 0); assertEquals((long) 1L << 16, id); } |
### Question:
IdentityGenerator { public static byte extractShardId(long id) { return (byte) ((id >>> 56) & 0x7fL); } private IdentityGenerator(); static Instant extractInstant(long id); static byte extractShardId(long id); static long generate(); static long generate(byte shardId); static final byte DEFAULT_SHARD_ID; static final Instant EPOCH; }### Answer:
@Test public void testExtractShardId() { long id = IdentityGenerator.doGenerate(SHARD_ID, TIME_DIFF, 10); byte shardId = IdentityGenerator.extractShardId(id); assertEquals(SHARD_ID, shardId); } |
### Question:
IdentityGenerator { public static Instant extractInstant(long id) { long time = (id & 0xffffffffff0000L) >>> 16; return EPOCH.plusMillis(time); } private IdentityGenerator(); static Instant extractInstant(long id); static byte extractShardId(long id); static long generate(); static long generate(byte shardId); static final byte DEFAULT_SHARD_ID; static final Instant EPOCH; }### Answer:
@Test public void testExtractInstant() { long id = IdentityGenerator.doGenerate(SHARD_ID, TIME_DIFF, 10); Instant instant = IdentityGenerator.extractInstant(id); assertEquals(INSTANT.getEpochSecond(), instant.getEpochSecond()); } |
### Question:
SceneStack implements Iterable<Scene> { boolean isEmpty() { return stack.isEmpty(); } SceneStack(@NonNull Callback callback); @Override Iterator<Scene> iterator(); }### Answer:
@Test public void testIsEmpty() { assertTrue(stack.isEmpty()); stack.push(new TestScene()); assertFalse(stack.isEmpty()); stack.push(new TestScene()); assertFalse(stack.isEmpty()); stack.pop(); assertFalse(stack.isEmpty()); stack.pop(); assertTrue(stack.isEmpty()); } |
### Question:
SceneStack implements Iterable<Scene> { int size() { return stack.size(); } SceneStack(@NonNull Callback callback); @Override Iterator<Scene> iterator(); }### Answer:
@Test public void testSize() { Scene scene1 = new TestScene(); Scene scene2 = new TestScene(); Scene scene3 = new TestScene(); assertEquals(0, stack.size()); stack.push(scene1); assertEquals(1, stack.size()); stack.pop(scene1); assertEquals(0, stack.size()); stack.push(scene2); stack.push(scene3); assertEquals(2, stack.size()); stack.pop(scene2); assertEquals(1, stack.size()); stack.pop(scene3); assertEquals(0, stack.size()); stack.pop(scene1); assertEquals(0, stack.size()); } |
### Question:
SceneStack implements Iterable<Scene> { @Nullable Scene peek() { return stack.peekFirst(); } SceneStack(@NonNull Callback callback); @Override Iterator<Scene> iterator(); }### Answer:
@Test public void testPeek() { Scene scene1 = new TestScene(); Scene scene2 = new TestScene(); Scene scene3 = new TestScene(); assertEquals(null, stack.peek()); stack.push(scene1); assertEquals(scene1, stack.peek()); stack.push(scene2); assertEquals(scene2, stack.peek()); stack.push(scene3); assertEquals(scene3, stack.peek()); stack.pop(scene2); assertEquals(scene3, stack.peek()); stack.pop(scene3); assertEquals(scene1, stack.peek()); stack.pop(scene1); assertEquals(null, stack.peek()); stack.pop(scene3); assertEquals(null, stack.peek()); } |
### Question:
SceneStack implements Iterable<Scene> { @Nullable Scene tail() { return stack.peekLast(); } SceneStack(@NonNull Callback callback); @Override Iterator<Scene> iterator(); }### Answer:
@Test public void testTail() { Scene scene1 = new TestScene(); Scene scene2 = new TestScene(); Scene scene3 = new TestScene(); assertEquals(null, stack.tail()); stack.push(scene1); assertEquals(scene1, stack.tail()); stack.push(scene2); assertEquals(scene1, stack.tail()); stack.push(scene3); assertEquals(scene1, stack.tail()); stack.pop(scene2); assertEquals(scene1, stack.tail()); stack.pop(scene1); assertEquals(scene3, stack.tail()); stack.pop(scene3); assertEquals(null, stack.tail()); stack.pop(scene2); assertEquals(null, stack.tail()); } |
### Question:
Stage implements Iterable<Scene> { @Nullable public Scene getTopScene() { return stack.peek(); } Stage(Director director); void popTopScene(); void pushScene(@NonNull Scene scene); void replaceTopScene(@NonNull Scene scene); void setRootScene(@NonNull Scene scene); boolean hasCurtainRunning(); void completeRunningCurtain(); boolean hasContainer(); void saveInstanceState(@NonNull Bundle outState); void suspend(); void restore(@NonNull ViewGroup container); void close(); void requestFocus(); void setWillPopTheLastScene(boolean willPopTheLastScene); boolean willPopTheLastScene(); void setBackHandler(BackHandler<Stage> backHandler); boolean handleBack(); boolean onHandleBack(); @Nullable Scene findSceneByTag(@NonNull String tag); @Nullable Scene findSceneById(int sceneId); @Nullable Scene getTopScene(); @Nullable Scene getRootScene(); @NonNull @Override Iterator<Scene> iterator(); int getSceneCount(); void setCurtainSuppler(CurtainSuppler suppler); }### Answer:
@Test public void testGetTopScene() { Scene scene1 = new TestScene(); Scene scene2 = new TestScene(); assertNull(stage.getTopScene()); stage.pushScene(scene1); assertEquals(scene1, stage.getTopScene()); stage.pushScene(scene2); assertEquals(scene2, stage.getTopScene()); } |
### Question:
Stage implements Iterable<Scene> { @Nullable public Scene getRootScene() { return stack.tail(); } Stage(Director director); void popTopScene(); void pushScene(@NonNull Scene scene); void replaceTopScene(@NonNull Scene scene); void setRootScene(@NonNull Scene scene); boolean hasCurtainRunning(); void completeRunningCurtain(); boolean hasContainer(); void saveInstanceState(@NonNull Bundle outState); void suspend(); void restore(@NonNull ViewGroup container); void close(); void requestFocus(); void setWillPopTheLastScene(boolean willPopTheLastScene); boolean willPopTheLastScene(); void setBackHandler(BackHandler<Stage> backHandler); boolean handleBack(); boolean onHandleBack(); @Nullable Scene findSceneByTag(@NonNull String tag); @Nullable Scene findSceneById(int sceneId); @Nullable Scene getTopScene(); @Nullable Scene getRootScene(); @NonNull @Override Iterator<Scene> iterator(); int getSceneCount(); void setCurtainSuppler(CurtainSuppler suppler); }### Answer:
@Test public void testGetRootScene() { Scene scene1 = new TestScene(); Scene scene2 = new TestScene(); assertNull(stage.getRootScene()); stage.pushScene(scene1); assertEquals(scene1, stage.getRootScene()); stage.pushScene(scene2); assertEquals(scene1, stage.getRootScene()); } |
### Question:
Stage implements Iterable<Scene> { public int getSceneCount() { return stack.size(); } Stage(Director director); void popTopScene(); void pushScene(@NonNull Scene scene); void replaceTopScene(@NonNull Scene scene); void setRootScene(@NonNull Scene scene); boolean hasCurtainRunning(); void completeRunningCurtain(); boolean hasContainer(); void saveInstanceState(@NonNull Bundle outState); void suspend(); void restore(@NonNull ViewGroup container); void close(); void requestFocus(); void setWillPopTheLastScene(boolean willPopTheLastScene); boolean willPopTheLastScene(); void setBackHandler(BackHandler<Stage> backHandler); boolean handleBack(); boolean onHandleBack(); @Nullable Scene findSceneByTag(@NonNull String tag); @Nullable Scene findSceneById(int sceneId); @Nullable Scene getTopScene(); @Nullable Scene getRootScene(); @NonNull @Override Iterator<Scene> iterator(); int getSceneCount(); void setCurtainSuppler(CurtainSuppler suppler); }### Answer:
@Test public void testGetSceneCount() { Scene scene1 = new TestScene(); Scene scene2 = new TestScene(); assertEquals(0, stage.getSceneCount()); stage.pushScene(scene1); assertEquals(1, stage.getSceneCount()); stage.pushScene(scene2); assertEquals(2, stage.getSceneCount()); stage.popScene(scene1); assertEquals(1, stage.getSceneCount()); } |
### Question:
Director implements Iterable<Stage> { @NonNull public Stage direct(@NonNull ViewGroup container) { return direct(container, container.getId()); } Director(); @NonNull static Director hire(@NonNull Activity activity, @Nullable Bundle savedInstanceState); boolean contains(int id); @Nullable Stage get(int id); @NonNull Stage direct(@NonNull ViewGroup container); @NonNull Stage direct(@NonNull ViewGroup container, int id); @Nullable Stage direct(@NonNull ViewGroup container, @NonNull Bundle savedState); @NonNull Stage direct(int id); @Nullable Stage direct(@NonNull Bundle savedState); @NonNull @Override Iterator<Stage> iterator(); void setSaveEnabled(boolean enabled); boolean isSaveEnabled(); abstract void requestFocus(); @Nullable Stage getFocusedStage(); void setBackHandler(@Nullable BackHandler<Director> backHandler); boolean handleBack(); boolean onHandleBack(); void setCurtainSuppler(@Nullable CurtainSuppler suppler); @Nullable Scene findSceneById(int sceneId); }### Answer:
@Test public void testTarget() { ViewGroup container1 = new TestContainer(RuntimeEnvironment.application); ViewGroup container2 = new TestContainer(RuntimeEnvironment.application); @IdRes int containerId1 = 1; @IdRes int containerId2 = 2; container1.setId(containerId1); container2.setId(containerId2); Stage stage1 = director.direct(container1); Stage stage2 = director.direct(container2); Scene scene1 = new TestScene(); Scene scene2 = new TestScene(); stage1.pushScene(scene1); stage1.pushScene(scene2); Scene scene3 = new TestScene(); Scene scene4 = new TestScene(); stage2.pushScene(scene3); stage2.pushScene(scene4); Director director2 = scene2.hireChildDirector(); Stage stage3 = director2.direct(new TestContainer(RuntimeEnvironment.application)); Scene scene5 = new TestScene(); stage3.pushScene(scene5); Director director3 = scene3.hireChildDirector(); Stage stage4 = director3.direct(new TestContainer(RuntimeEnvironment.application)); Scene scene6 = new TestScene(); stage4.pushScene(scene6); scene5.setTarget(scene6); assertEquals(scene6, scene5.getTarget()); } |
### Question:
RunJhsCliParser implements CliParser<RunJhsCommand> { @Override public RunJhsCommand parse(String[] args) { DefaultParser parser = new DefaultParser(); CommandLine cmdLine; cmdLine = CliHelper.tryParse(parser, options, args); return RunJhsCommand.builder() .clientId(cmdLine.getOptionValue(CliConsts.CLIENT_ID_OPTION_NAME)) .logBucket(cmdLine.getOptionValue(CliConsts.LOG_BUCKET_OPTION_NAME)) .build(); } @Override RunJhsCommand parse(String[] args); @Override void printHelp(); @Override boolean enoughArgs(String[] args); static final String CMD_NAME; }### Answer:
@Test public void testParseWithoutUser() { RunJhsCommand jhsCmd = PARSER.parse(new String[]{ CliTestHelpers.toStrOpt(CliConsts.CLIENT_ID_OPTION_NAME, DUMMY_CLIENT_ID), CliTestHelpers.toStrOpt(CliConsts.LOG_BUCKET_OPTION_NAME, DUMMY_BUCKET) }); assertEquals(jhsCmd.clientId(), DUMMY_CLIENT_ID); }
@Test public void testParseWithUser() { RunJhsCommand jhsCmd = PARSER.parse(new String[]{ CliTestHelpers.toStrOpt(CliConsts.CLIENT_ID_OPTION_NAME, DUMMY_CLIENT_ID), CliTestHelpers.toStrOpt(CliConsts.LOG_BUCKET_OPTION_NAME, DUMMY_BUCKET) }); assertEquals(jhsCmd.clientId(), DUMMY_CLIENT_ID); } |
### Question:
DumpHistoryCliParser implements CliParser<DumpHistoryCommand> { @Override public DumpHistoryCommand parse(String[] args) { DefaultParser parser = new DefaultParser(); CommandLine cmdLine; cmdLine = CliHelper.tryParse(parser, options, args); return DumpHistoryCommand.builder() .clientId(cmdLine.getOptionValue(CliConsts.CLIENT_ID_OPTION_NAME)) .applicationId(ConverterUtils.toApplicationId(cmdLine.getOptionValue( CliConsts.JOB_ID_OPTION_NAME))) .logBucket(cmdLine.getOptionValue(CliConsts.LOG_BUCKET_OPTION_NAME)) .build(); } @Override DumpHistoryCommand parse(String[] args); @Override void printHelp(); @Override boolean enoughArgs(String[] args); static final String CMD_NAME; }### Answer:
@Test public void testParse() { DumpHistoryCommand dumpCmd = PARSER.parse(new String[]{ CliTestHelpers.toStrOpt(CliConsts.JOB_ID_OPTION_NAME, DUMMY_APP_ID), CliTestHelpers.toStrOpt(CliConsts.CLIENT_ID_OPTION_NAME, DUMMY_CLIENT_ID), CliTestHelpers.toStrOpt(CliConsts.LOG_BUCKET_OPTION_NAME, DUMMY_BUCKET) }); assertEquals(dumpCmd.applicationId().toString(), DUMMY_APP_ID); assertEquals(dumpCmd.clientId(), DUMMY_CLIENT_ID); assertEquals(dumpCmd.logBucket(), DUMMY_BUCKET); } |
### Question:
ClusterPlacement { static ClusterPlacement from(String token) { String[] splits = token.split("-"); if (splits.length != 2) { throw new IllegalArgumentException("Could not parse token: " + token); } try { return new ClusterPlacementBuilder() .clusterNumber(Integer.valueOf(splits[0])) .clusterGeneration(Long.valueOf(splits[1])) .build(); } catch (NumberFormatException nfe) { throw new IllegalArgumentException("Could not parse token: " + token, nfe); } } Optional<Cluster> findIn(List<Cluster> clusters); }### Answer:
@Test public void testFrom() { ClusterPlacement clusterPlacement = ClusterPlacement.from("10-15"); assertThat(clusterPlacement.clusterNumber(), is(10)); assertThat(clusterPlacement.clusterGeneration(), is(15L)); } |
### Question:
ClusterPlacement { String token() { return String.format("%s-%s", clusterNumber(), clusterGeneration()); } Optional<Cluster> findIn(List<Cluster> clusters); }### Answer:
@Test public void testToken() { final ClusterPlacement clusterPlacement = new ClusterPlacementBuilder().clusterNumber(10).clusterGeneration(15L).build(); assertThat(clusterPlacement.token(), is("10-15")); } |
### Question:
ClusterPlacement { static List<Cluster> filterClusters( List<Cluster> clusters, List<ClusterPlacement> allPlacements) { Set<String> clusterPlacements = allPlacements.stream() .map(ClusterPlacement::token) .collect(toSet()); return clusters.stream() .filter(cluster -> clusterPlacements.contains(placement(cluster).token())) .collect(toList()); } Optional<Cluster> findIn(List<Cluster> clusters); }### Answer:
@Test public void testFilterClusters() { final List<ClusterPlacement> clusterPlacements = Arrays.asList(new ClusterPlacementBuilder().clusterNumber(0).clusterGeneration(1).build(), new ClusterPlacementBuilder().clusterNumber(1).clusterGeneration(1).build(), new ClusterPlacementBuilder().clusterNumber(2).clusterGeneration(0).build()); final Cluster cluster1 = new Cluster(); cluster1.labels = Collections.singletonMap(SPYDRA_PLACEMENT_TOKEN_LABEL, "0-1"); final Cluster cluster2 = new Cluster(); cluster2.labels = Collections.singletonMap(SPYDRA_PLACEMENT_TOKEN_LABEL, "10-15"); final List<Cluster> filterClusters = ClusterPlacement.filterClusters(Arrays.asList(cluster1, cluster2), clusterPlacements); assertThat(filterClusters, hasSize(1)); assertThat(filterClusters, contains(cluster1)); } |
### Question:
ClusterPlacement { public Optional<Cluster> findIn(List<Cluster> clusters) { return clusters.stream() .filter(cluster -> this.equals(placement(cluster))) .findFirst(); } Optional<Cluster> findIn(List<Cluster> clusters); }### Answer:
@Test public void testFindIn() { final ClusterPlacement missingPlacement = new ClusterPlacementBuilder().clusterNumber(0).clusterGeneration(0).build(); final ClusterPlacement existingPlacement = new ClusterPlacementBuilder().clusterNumber(0).clusterGeneration(1).build(); final Cluster cluster1 = new Cluster(); cluster1.labels = Collections.singletonMap(SPYDRA_PLACEMENT_TOKEN_LABEL, "0-1"); final Cluster cluster2 = new Cluster(); cluster2.labels = Collections.singletonMap(SPYDRA_PLACEMENT_TOKEN_LABEL, "10-15"); final List<Cluster> clusters = Arrays.asList(cluster1, cluster2); assertFalse(missingPlacement.findIn(clusters).isPresent()); assertTrue(existingPlacement.findIn(clusters).isPresent()); assertThat(existingPlacement.findIn(clusters).get(), is(cluster1)); } |
### Question:
DynamicSubmitter extends Submitter { public boolean releaseCluster(SpydraArgument arguments, DataprocApi dataprocApi) throws IOException { try { waitForHistoryToBeMoved(arguments); } finally { return dataprocApi.deleteCluster(arguments); } } DynamicSubmitter(); DynamicSubmitter(DataprocApi dataprocApi, GcpUtils gcpUtils); @Override boolean executeJob(SpydraArgument argument); boolean acquireCluster(SpydraArgument arguments, DataprocApi dataprocApi); static String generateName(); boolean releaseCluster(SpydraArgument arguments, DataprocApi dataprocApi); static final String SPYDRA_CLUSTER_LABEL; }### Answer:
@Test public void releaseErrorCluster() throws Exception { List<Cluster> clusters = Arrays.asList(errorCluster(), errorCluster()); SpydraArgument.Pooling pooling = new SpydraArgument.Pooling(); arguments.setPooling(pooling); arguments.setClientId(clientId); arguments.cluster.setName(spydraClusterName); when(dataprocApi.listClusters(eq(arguments), anyMapOf(String.class, String.class))) .thenReturn(clusters); when(dataprocApi.deleteCluster(arguments)).thenReturn(true); assertTrue("A broken cluster should be collected without problems.", dynamicSubmitter.releaseCluster(arguments, dataprocApi)); verify(dataprocApi).deleteCluster(arguments); } |
### Question:
DumpLogsCliParser implements CliParser<DumpLogsCommand> { @Override public DumpLogsCommand parse(String[] args) { DefaultParser parser = new DefaultParser(); CommandLine cmdLine; cmdLine = CliHelper.tryParse(parser, options, args); return DumpLogsCommand.builder() .clientId(cmdLine.getOptionValue(CliConsts.CLIENT_ID_OPTION_NAME)) .applicationId(ConverterUtils.toApplicationId(cmdLine.getOptionValue( CliConsts.JOB_ID_OPTION_NAME))) .username(cmdLine.getOptionValue(CliConsts.USERNAME_OPTION_NAME)) .logBucket(cmdLine.getOptionValue(CliConsts.LOG_BUCKET_OPTION_NAME)) .build(); } @Override DumpLogsCommand parse(String[] args); @Override void printHelp(); @Override boolean enoughArgs(String[] args); }### Answer:
@Test public void testParse() { DumpLogsCommand dumpCmd = PARSER.parse(new String[]{ CliTestHelpers.toStrOpt(CliConsts.JOB_ID_OPTION_NAME, DUMMY_APP_ID), CliTestHelpers.toStrOpt(CliConsts.CLIENT_ID_OPTION_NAME, DUMMY_CLIENT_ID), CliTestHelpers.toStrOpt(CliConsts.USERNAME_OPTION_NAME, DUMMY_USER), CliTestHelpers.toStrOpt(CliConsts.LOG_BUCKET_OPTION_NAME, DUMMY_BUCKET) }); assertEquals(dumpCmd.applicationId().toString(), DUMMY_APP_ID); assertEquals(dumpCmd.clientId(), DUMMY_CLIENT_ID); assertEquals(dumpCmd.username(), DUMMY_USER); assertEquals(dumpCmd.logBucket(), DUMMY_BUCKET); } |
### Question:
BookController { @DeleteMapping("/{id}") public void delete(@PathVariable Long id) { System.out.println(id); bookService.delete(id); } @GetMapping // @JsonView(BookListView.class) @ApiOperation("查询图书信息") Page<BookInfo> query(BookCondition condition, Pageable pageable); @GetMapping("/{id}") // @JsonView(BookDetailView.class) @ApiOperation("获取图书详细信息") BookInfo getInfo(@ApiParam("图书ID") @PathVariable Long id) thr; @PostMapping BookInfo create(@Valid @RequestBody BookInfo info, BindingResult result); @PutMapping("/{id}") BookInfo update(@Valid @RequestBody BookInfo info, BindingResult result); @DeleteMapping("/{id}") void delete(@PathVariable Long id); }### Answer:
@Test public void whenDeleteSuccess() throws Exception { mockMvc.perform(delete("/book/1").contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()); } |
### Question:
OpenJdkOngoingRecording implements OngoingRecording { @Override public OpenJdkRecordingData snapshot(final Instant start, final Instant end) { if (recording.getState() != RecordingState.RUNNING) { throw new IllegalStateException("Cannot snapshot recording that is not running"); } final Recording snapshot = FlightRecorder.getFlightRecorder().takeSnapshot(); snapshot.setName(recording.getName()); return new OpenJdkRecordingData(snapshot, start, end); } OpenJdkOngoingRecording(final Recording recording); @Override OpenJdkRecordingData stop(); @Override OpenJdkRecordingData snapshot(final Instant start, final Instant end); @Override void close(); }### Answer:
@Test public void testSnapshot() { final OpenJdkRecordingData recordingData = ongoingRecording.snapshot(start, end); assertEquals(TEST_NAME, recordingData.getName()); assertEquals(start, recordingData.getStart()); assertEquals(end, recordingData.getEnd()); assertNotEquals( recording, recordingData.getRecording(), "make sure we didn't get our mocked recording"); recordingData.release(); verify(recording, never()).stop(); } |
### Question:
OpenJdkOngoingRecording implements OngoingRecording { @Override public void close() { recording.close(); } OpenJdkOngoingRecording(final Recording recording); @Override OpenJdkRecordingData stop(); @Override OpenJdkRecordingData snapshot(final Instant start, final Instant end); @Override void close(); }### Answer:
@Test public void testClose() { ongoingRecording.close(); verify(recording).close(); } |
### Question:
OpenJdkController implements Controller { @Override public OpenJdkOngoingRecording createRecording(final String recordingName) { final Recording recording = new Recording(); recording.setName(recordingName); recording.setSettings(recordingSettings); recording.setMaxSize(RECORDING_MAX_SIZE); recording.setMaxAge(RECORDING_MAX_AGE); recording.start(); return new OpenJdkOngoingRecording(recording); } OpenJdkController(final Config config); @Override OpenJdkOngoingRecording createRecording(final String recordingName); }### Answer:
@Test public void testCreateContinuousRecording() throws IOException { final Recording recording = controller.createRecording(TEST_NAME).stop().getRecording(); assertEquals(TEST_NAME, recording.getName()); assertEquals( JfpUtils.readNamedJfpResource(OpenJdkController.JFP, OVERRIDES), recording.getSettings()); assertEquals(OpenJdkController.RECORDING_MAX_SIZE, recording.getMaxSize()); assertEquals(OpenJdkController.RECORDING_MAX_AGE, recording.getMaxAge()); recording.close(); } |
### Question:
OpenJdkRecordingData implements RecordingData { @Override public InputStream getStream() throws IOException { return recording.getStream(start, end); } OpenJdkRecordingData(final Recording recording); OpenJdkRecordingData(final Recording recording, final Instant start, final Instant end); @Override InputStream getStream(); @Override void release(); @Override String getName(); @Override String toString(); @Override Instant getStart(); @Override Instant getEnd(); }### Answer:
@Test public void testGetStream() throws IOException { assertEquals(stream, recordingData.getStream()); }
@Test public void testCustomGetStream() throws IOException { assertEquals(customStream, customRecordingData.getStream()); } |
### Question:
OpenJdkRecordingData implements RecordingData { @Override public void release() { recording.close(); } OpenJdkRecordingData(final Recording recording); OpenJdkRecordingData(final Recording recording, final Instant start, final Instant end); @Override InputStream getStream(); @Override void release(); @Override String getName(); @Override String toString(); @Override Instant getStart(); @Override Instant getEnd(); }### Answer:
@Test public void testRelease() { recordingData.release(); verify(recording).close(); } |
### Question:
OpenJdkRecordingData implements RecordingData { @Override public String getName() { return recording.getName(); } OpenJdkRecordingData(final Recording recording); OpenJdkRecordingData(final Recording recording, final Instant start, final Instant end); @Override InputStream getStream(); @Override void release(); @Override String getName(); @Override String toString(); @Override Instant getStart(); @Override Instant getEnd(); }### Answer:
@Test public void testGetName() { assertEquals(TEST_NAME, recordingData.getName()); } |
### Question:
OpenJdkRecordingData implements RecordingData { @Override public String toString() { return "OpenJdkRecording: " + getName(); } OpenJdkRecordingData(final Recording recording); OpenJdkRecordingData(final Recording recording, final Instant start, final Instant end); @Override InputStream getStream(); @Override void release(); @Override String getName(); @Override String toString(); @Override Instant getStart(); @Override Instant getEnd(); }### Answer:
@Test public void testToString() { assertThat(recordingData.toString(), containsString(TEST_NAME)); } |
### Question:
OpenJdkRecordingData implements RecordingData { @Override public Instant getStart() { return start; } OpenJdkRecordingData(final Recording recording); OpenJdkRecordingData(final Recording recording, final Instant start, final Instant end); @Override InputStream getStream(); @Override void release(); @Override String getName(); @Override String toString(); @Override Instant getStart(); @Override Instant getEnd(); }### Answer:
@Test public void testGetStart() { assertEquals(start, recordingData.getStart()); }
@Test public void testCustomGetStart() { assertEquals(customStart, customRecordingData.getStart()); } |
### Question:
OpenJdkRecordingData implements RecordingData { @Override public Instant getEnd() { return end; } OpenJdkRecordingData(final Recording recording); OpenJdkRecordingData(final Recording recording, final Instant start, final Instant end); @Override InputStream getStream(); @Override void release(); @Override String getName(); @Override String toString(); @Override Instant getStart(); @Override Instant getEnd(); }### Answer:
@Test public void testGetEnd() { assertEquals(end, recordingData.getEnd()); }
@Test public void testCustomGetEnd() { assertEquals(customEnd, customRecordingData.getEnd()); } |
### Question:
Packer implements Writable, MessageFormatter { @Override public void writeNull() { buffer.put(NULL); } Packer(Codec codec, ByteBufferConsumer sink, ByteBuffer buffer, boolean manualReset); Packer(Codec codec, ByteBufferConsumer sink, ByteBuffer buffer); Packer(ByteBufferConsumer sink, ByteBuffer buffer); Packer(ByteBufferConsumer sink, ByteBuffer buffer, boolean manualReset); @Override boolean format(T message, Mapper<T> mapper); int messageCount(); void reset(); @Override void flush(); @Override void writeNull(); @Override void writeBoolean(boolean value); @Override @SuppressWarnings({"rawtypes", "unchecked"}) void writeObject(Object value, EncodingCache encodingCache); @Override void writeMap(
Map<? extends CharSequence, ? extends Object> map, EncodingCache encodingCache); @Override void writeString(CharSequence s, EncodingCache encodingCache); @Override void writeUTF8(byte[] string, int offset, int length); @Override void writeUTF8(byte[] string); @Override void writeUTF8(UTF8BytesString string); @Override void writeBinary(byte[] binary, int offset, int length); @Override void writeBinary(ByteBuffer binary); @Override void writeInt(int value); @Override void writeLong(long value); @Override void writeFloat(float value); @Override void writeDouble(double value); @Override void startMap(int elementCount); @Override void startArray(int elementCount); }### Answer:
@Test public void testWriteNull() { MessageFormatter messageFormatter = new Packer( new ByteBufferConsumer() { @Override public void accept(int messageCount, ByteBuffer buffy) { MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(buffy); try { assertEquals(1, unpacker.unpackArrayHeader()); unpacker.unpackNil(); } catch (IOException e) { Assert.fail(e.getMessage()); } } }, ByteBuffer.allocate(25)); messageFormatter.format( null, new Mapper<Object>() { @Override public void map(Object x, Writable w) { w.writeObject(x, EncodingCachingStrategies.NO_CACHING); } }); messageFormatter.flush(); } |
### Question:
OpenJdkRecordingData implements RecordingData { Recording getRecording() { return recording; } OpenJdkRecordingData(final Recording recording); OpenJdkRecordingData(final Recording recording, final Instant start, final Instant end); @Override InputStream getStream(); @Override void release(); @Override String getName(); @Override String toString(); @Override Instant getStart(); @Override Instant getEnd(); }### Answer:
@Test public void getRecording() { assertEquals(recording, recordingData.getRecording()); } |
### Question:
DeadlockEventFactory { final List<? extends Event> collectEvents() { if (!isDeadlockEventEnabled()) { return Collections.emptyList(); } long[] locked = threadMXBean.findDeadlockedThreads(); if (locked == null) { return Collections.emptyList(); } long id = deadlockCounter.getAndIncrement(); List<Event> events = new ArrayList<>(); DeadlockEvent event = new DeadlockEvent(id, locked.length); events.add(event); if (isDeadlockedThreadEventEnabled()) { ThreadInfo[] lockedThreads = threadMXBean.getThreadInfo(locked, true, true); Map<LockInfo, Set<StackTraceElement>> waitingFrames = new TreeMap<>(Comparator.comparingLong(LockInfo::getIdentityHashCode)); for (ThreadInfo ti : lockedThreads) { waitingFrames .computeIfAbsent(ti.getLockInfo(), k -> new HashSet<>()) .add(ti.getStackTrace()[0]); } for (ThreadInfo ti : lockedThreads) { processLockedMonitors(ti, id, waitingFrames, events); processSynchronizables(ti, id, waitingFrames, events); } } return events; } DeadlockEventFactory(ThreadMXBean threadMXBean); DeadlockEventFactory(); static void registerEvents(); }### Answer:
@Test void collectEvents() throws Exception { assertNoDeadlocks(); int deadlocked = setupMonitorDeadlock(); assertDeadlock(true, deadlocked); deadlocked += setupSynchronizableDeadlock(); assertDeadlock(false, deadlocked); assertEquals( 1, disabledDetailsEventFactory.collectEvents().stream() .filter(e -> e instanceof DeadlockEvent) .count()); assertTrue(allDisabledEventFactory.collectEvents().isEmpty()); } |
### Question:
JfpUtils { public static Map<String, String> readNamedJfpResource( final String name, final String overridesFile) throws IOException { final Map<String, String> result; try (final InputStream stream = getNamedResource(name)) { result = readJfpFile(stream); } if (overridesFile != null) { try (final InputStream stream = new FileInputStream(overridesFile)) { result.putAll(readJfpFile(stream)); } } return Collections.unmodifiableMap(result); } private JfpUtils(); static Map<String, String> readNamedJfpResource(
final String name, final String overridesFile); }### Answer:
@Test public void testLoadingContinuousConfig() throws IOException { final Map<String, String> config = JfpUtils.readNamedJfpResource(OpenJdkController.JFP, null); assertEquals("true", config.get(CONFIG_ENTRY)); assertNull(config.get(CONFIG_OVERRIDE_ENTRY)); }
@Test public void testLoadingContinuousConfigWithOverride() throws IOException { final Map<String, String> config = JfpUtils.readNamedJfpResource(OpenJdkController.JFP, OVERRIDES); assertEquals("true", config.get(CONFIG_ENTRY)); assertEquals("200", config.get(CONFIG_OVERRIDE_ENTRY)); } |
### Question:
StreamUtils { public static <T> T readStream( final InputStream is, final int expectedSize, final BytesConsumer<T> consumer) throws IOException { final byte[] bytes = new byte[expectedSize]; int remaining = expectedSize; while (remaining > 0) { final int offset = expectedSize - remaining; final int read = is.read(bytes, offset, remaining); if (read == -1) { return consumer.consume(bytes, 0, offset); } remaining -= read; } final List<BufferChunk> additionalChunks = new ArrayList<>(); int additionalChunksLength = 0; while (true) { final BufferChunk chunk = new BufferChunk(Math.max(32, is.available())); final int readLength = chunk.readFrom(is); if (readLength < 0) { break; } else { additionalChunks.add(chunk); additionalChunksLength += readLength; } } final byte[] result = new byte[bytes.length + additionalChunksLength]; System.arraycopy(bytes, 0, result, 0, bytes.length); int offset = bytes.length; for (final BufferChunk chunk : additionalChunks) { offset += chunk.appendToArray(result, offset); } return consumer.consume(result, 0, result.length); } static T gzipStream(
InputStream is, final int expectedSize, final BytesConsumer<T> consumer); static T lz4Stream(
InputStream is, final int expectedSize, final BytesConsumer<T> consumer); static T readStream(
final InputStream is, final int expectedSize, final BytesConsumer<T> consumer); }### Answer:
@Test public void readStreamNoCompression() throws IOException { final int expectedSize = 1; final byte[] bytes = StreamUtils.readStream(testRecordingStream(), expectedSize, CONSUME_TO_BYTES); assertArrayEquals(testRecordingBytes, bytes); }
@Test public void readStreamNoCompressionLargeExpectedSize() throws IOException { final int expectedSize = testRecordingBytes.length * 2; final byte[] bytes = StreamUtils.readStream(testRecordingStream(), expectedSize, CONSUME_TO_BYTES); assertArrayEquals(testRecordingBytes, bytes); } |
### Question:
Packer implements Writable, MessageFormatter { @Override public void writeBoolean(boolean value) { buffer.put(value ? TRUE : FALSE); } Packer(Codec codec, ByteBufferConsumer sink, ByteBuffer buffer, boolean manualReset); Packer(Codec codec, ByteBufferConsumer sink, ByteBuffer buffer); Packer(ByteBufferConsumer sink, ByteBuffer buffer); Packer(ByteBufferConsumer sink, ByteBuffer buffer, boolean manualReset); @Override boolean format(T message, Mapper<T> mapper); int messageCount(); void reset(); @Override void flush(); @Override void writeNull(); @Override void writeBoolean(boolean value); @Override @SuppressWarnings({"rawtypes", "unchecked"}) void writeObject(Object value, EncodingCache encodingCache); @Override void writeMap(
Map<? extends CharSequence, ? extends Object> map, EncodingCache encodingCache); @Override void writeString(CharSequence s, EncodingCache encodingCache); @Override void writeUTF8(byte[] string, int offset, int length); @Override void writeUTF8(byte[] string); @Override void writeUTF8(UTF8BytesString string); @Override void writeBinary(byte[] binary, int offset, int length); @Override void writeBinary(ByteBuffer binary); @Override void writeInt(int value); @Override void writeLong(long value); @Override void writeFloat(float value); @Override void writeDouble(double value); @Override void startMap(int elementCount); @Override void startArray(int elementCount); }### Answer:
@Test public void testWriteBoolean() { MessageFormatter messageFormatter = new Packer( new ByteBufferConsumer() { @Override public void accept(int messageCount, ByteBuffer buffy) { MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(buffy); try { assertEquals(1, unpacker.unpackArrayHeader()); assertTrue(unpacker.unpackBoolean()); } catch (IOException e) { Assert.fail(e.getMessage()); } } }, ByteBuffer.allocate(25)); messageFormatter.format( true, new Mapper<Boolean>() { @Override public void map(Boolean x, Writable w) { w.writeBoolean(x); } }); messageFormatter.flush(); } |
### Question:
ConstantPool { public T get(int index) { return index < 0 ? null : reverseIndexMap.get(index); } ConstantPool(); ConstantPool(int startingIndex); T get(int index); int getOrInsert(T constant); void insert(int ptr, T constant); int size(); }### Answer:
@Test void getByIndexEmpty() { assertNull(instance.get(-1)); assertNull(instance.get(0)); } |
### Question:
ProfileUploader { OkHttpClient getClient() { return client; } ProfileUploader(final Config config); ProfileUploader(
final Config config, final RatelimitedLogger ratelimitedLogger, final String containerId); void upload(final RecordingType type, final RecordingData data); void shutdown(); }### Answer:
@Test void testOkHttpClientForcesCleartextConnspecWhenNotUsingTLS() { when(config.getFinalProfilingUrl()).thenReturn("http: uploader = new ProfileUploader(config); final List<ConnectionSpec> connectionSpecs = uploader.getClient().connectionSpecs(); assertEquals(connectionSpecs.size(), 1); assertTrue(connectionSpecs.contains(ConnectionSpec.CLEARTEXT)); }
@Test void testOkHttpClientUsesDefaultConnspecsOverTLS() { when(config.getFinalProfilingUrl()).thenReturn("https: uploader = new ProfileUploader(config); final List<ConnectionSpec> connectionSpecs = uploader.getClient().connectionSpecs(); assertEquals(connectionSpecs.size(), 2); assertTrue(connectionSpecs.contains(ConnectionSpec.MODERN_TLS)); assertTrue(connectionSpecs.contains(ConnectionSpec.CLEARTEXT)); } |
### Question:
ConstantPool { public void insert(int ptr, T constant) { if (constant == null) { if (ptr != -1) { throw new IllegalArgumentException(); } return; } indexMap.put(constant, ptr); reverseIndexMap.put(ptr, constant); offset = Math.max(offset, ptr + 1); } ConstantPool(); ConstantPool(int startingIndex); T get(int index); int getOrInsert(T constant); void insert(int ptr, T constant); int size(); }### Answer:
@Test void insertInvalid() { assertThrows(IllegalArgumentException.class, () -> instance.insert(1, null)); }
@Test void insertNull() { assertDoesNotThrow(() -> instance.insert(-1, null)); } |
### Question:
ProfileUploader { public void shutdown() { okHttpExecutorService.shutdownNow(); try { okHttpExecutorService.awaitTermination(TERMINATION_TIMEOUT, TimeUnit.SECONDS); } catch (final InterruptedException e) { log.warn("Wait for executor shutdown interrupted"); } client.connectionPool().evictAll(); } ProfileUploader(final Config config); ProfileUploader(
final Config config, final RatelimitedLogger ratelimitedLogger, final String containerId); void upload(final RecordingType type, final RecordingData data); void shutdown(); }### Answer:
@Test public void testShutdown() throws IOException, InterruptedException { uploader.shutdown(); final RecordingData recording = mockRecordingData(RECORDING_RESOURCE); uploader.upload(RECORDING_TYPE, recording); assertNull(server.takeRequest(100, TimeUnit.MILLISECONDS), "No more requests"); verify(recording.getStream()).close(); verify(recording).release(); } |
### Question:
ProfilingThreadFactory implements ThreadFactory { @Override public Thread newThread(final Runnable r) { final Thread t = new Thread(THREAD_GROUP, r, name); t.setDaemon(true); return t; } ProfilingThreadFactory(final String name); @Override Thread newThread(final Runnable r); }### Answer:
@Test public void testThreadName() { final Thread thread = factory.newThread(() -> {}); assertEquals("test-name", thread.getName()); } |
### Question:
ProfilingSystem { final Duration getStartupDelay() { return startupDelay; } ProfilingSystem(
final Controller controller,
final RecordingDataListener dataListener,
final Duration startupDelay,
final Duration startupDelayRandomRange,
final Duration uploadPeriod,
final boolean isStartingFirst); ProfilingSystem(
final Controller controller,
final RecordingDataListener dataListener,
final Duration baseStartupDelay,
final Duration startupDelayRandomRange,
final Duration uploadPeriod,
final boolean isStartingFirst,
final ScheduledExecutorService executorService,
final ThreadLocalRandom threadLocalRandom); final void start(); final void shutdown(); boolean isStarted(); static final int DEFAULT_STACK_DEPTH; static final int MAX_STACK_DEPTH; }### Answer:
@Test public void testRandomizedStartupDelay() throws ConfigurationException { final Duration startupDelay = Duration.ofMillis(100); final Duration startupDelayRandomRange = Duration.ofMillis(500); final Duration additionalRandomDelay = Duration.ofMillis(300); when(threadLocalRandom.nextLong(startupDelayRandomRange.toMillis())) .thenReturn(additionalRandomDelay.toMillis()); final ProfilingSystem system = new ProfilingSystem( controller, listener, startupDelay, startupDelayRandomRange, Duration.ofMillis(100), false, pool, threadLocalRandom); final Duration randomizedDelay = system.getStartupDelay(); assertEquals(startupDelay.plus(additionalRandomDelay), randomizedDelay); }
@Test public void testFixedStartupDelay() throws ConfigurationException { final Duration startupDelay = Duration.ofMillis(100); final ProfilingSystem system = new ProfilingSystem( controller, listener, startupDelay, Duration.ZERO, Duration.ofMillis(100), false, pool, threadLocalRandom); assertEquals(startupDelay, system.getStartupDelay()); } |
### Question:
ConstantPool { public int size() { return indexMap.size(); } ConstantPool(); ConstantPool(int startingIndex); T get(int index); int getOrInsert(T constant); void insert(int ptr, T constant); int size(); }### Answer:
@Test void size() { String value1 = "test1"; String value2 = "test2"; assertEquals(0, instance.size()); instance.insert(0, value1); assertEquals(1, instance.size()); instance.getOrInsert(value1); assertEquals(1, instance.size()); instance.getOrInsert(value2); assertEquals(2, instance.size()); } |
### Question:
OpenJdkOngoingRecording implements OngoingRecording { @Override public OpenJdkRecordingData stop() { if (recording.getState() != RecordingState.RUNNING) { throw new IllegalStateException("Cannot stop recording that is not running"); } recording.stop(); return new OpenJdkRecordingData(recording); } OpenJdkOngoingRecording(final Recording recording); @Override OpenJdkRecordingData stop(); @Override OpenJdkRecordingData snapshot(final Instant start, final Instant end); @Override void close(); }### Answer:
@Test public void testStop() { assertEquals(recording, ongoingRecording.stop().getRecording()); verify(recording).stop(); }
@Test public void testStopOnStopped() { when(recording.getState()).thenReturn(RecordingState.STOPPED); assertThrows( IllegalStateException.class, () -> { ongoingRecording.stop(); }); verify(recording, never()).stop(); } |
### Question:
Java8OptionalConverterFactory extends Converter.Factory { public static Java8OptionalConverterFactory create() { return new Java8OptionalConverterFactory(); } private Java8OptionalConverterFactory(); static Java8OptionalConverterFactory create(); @Override @Nullable Converter<ResponseBody, ?> responseBodyConverter(
Type type, Annotation[] annotations, Retrofit retrofit); }### Answer:
@Test public void delegates() throws IOException { Object object = new Object(); Retrofit retrofit = new Retrofit.Builder() .baseUrl(server.url("/")) .addConverterFactory( new Converter.Factory() { @Nullable @Override public Converter<ResponseBody, ?> responseBodyConverter( Type type, Annotation[] annotations, Retrofit retrofit) { if (getRawType(type) != Object.class) { return null; } return value -> object; } }) .addConverterFactory(Java8OptionalConverterFactory.create()) .build(); server.enqueue(new MockResponse()); Service service = retrofit.create(Service.class); Optional<Object> optional = service.optional().execute().body(); assertThat(optional).isNotNull(); assertThat(optional.get()).isSameAs(object); } |
### Question:
NetworkBehavior { public void setVariancePercent(int variancePercent) { checkPercentageValidity(variancePercent, "Variance percentage must be between 0 and 100."); this.variancePercent = variancePercent; } private NetworkBehavior(Random random); static NetworkBehavior create(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static NetworkBehavior create(Random random); void setDelay(long amount, TimeUnit unit); long delay(TimeUnit unit); void setVariancePercent(int variancePercent); int variancePercent(); void setFailurePercent(int failurePercent); int failurePercent(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. void setFailureException(Throwable exception); Throwable failureException(); int errorPercent(); void setErrorPercent(int errorPercent); @SuppressWarnings("ConstantConditions") // Guarding API nullability. void setErrorFactory(Callable<Response<?>> errorFactory); Response<?> createErrorResponse(); boolean calculateIsFailure(); boolean calculateIsError(); long calculateDelay(TimeUnit unit); }### Answer:
@Test public void varianceRestrictsRange() { try { behavior.setVariancePercent(-13); fail(); } catch (IllegalArgumentException e) { assertThat(e).hasMessage("Variance percentage must be between 0 and 100."); } try { behavior.setVariancePercent(174); fail(); } catch (IllegalArgumentException e) { assertThat(e).hasMessage("Variance percentage must be between 0 and 100."); } } |
### Question:
NetworkBehavior { public void setFailurePercent(int failurePercent) { checkPercentageValidity(failurePercent, "Failure percentage must be between 0 and 100."); this.failurePercent = failurePercent; } private NetworkBehavior(Random random); static NetworkBehavior create(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static NetworkBehavior create(Random random); void setDelay(long amount, TimeUnit unit); long delay(TimeUnit unit); void setVariancePercent(int variancePercent); int variancePercent(); void setFailurePercent(int failurePercent); int failurePercent(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. void setFailureException(Throwable exception); Throwable failureException(); int errorPercent(); void setErrorPercent(int errorPercent); @SuppressWarnings("ConstantConditions") // Guarding API nullability. void setErrorFactory(Callable<Response<?>> errorFactory); Response<?> createErrorResponse(); boolean calculateIsFailure(); boolean calculateIsError(); long calculateDelay(TimeUnit unit); }### Answer:
@Test public void failureRestrictsRange() { try { behavior.setFailurePercent(-13); fail(); } catch (IllegalArgumentException e) { assertThat(e).hasMessage("Failure percentage must be between 0 and 100."); } try { behavior.setFailurePercent(174); fail(); } catch (IllegalArgumentException e) { assertThat(e).hasMessage("Failure percentage must be between 0 and 100."); } } |
### Question:
NetworkBehavior { @SuppressWarnings("ConstantConditions") public void setFailureException(Throwable exception) { if (exception == null) { throw new NullPointerException("exception == null"); } this.failureException = exception; } private NetworkBehavior(Random random); static NetworkBehavior create(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static NetworkBehavior create(Random random); void setDelay(long amount, TimeUnit unit); long delay(TimeUnit unit); void setVariancePercent(int variancePercent); int variancePercent(); void setFailurePercent(int failurePercent); int failurePercent(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. void setFailureException(Throwable exception); Throwable failureException(); int errorPercent(); void setErrorPercent(int errorPercent); @SuppressWarnings("ConstantConditions") // Guarding API nullability. void setErrorFactory(Callable<Response<?>> errorFactory); Response<?> createErrorResponse(); boolean calculateIsFailure(); boolean calculateIsError(); long calculateDelay(TimeUnit unit); }### Answer:
@Test public void failureExceptionIsNotNull() { try { behavior.setFailureException(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("exception == null"); } } |
### Question:
NetworkBehavior { public void setErrorPercent(int errorPercent) { checkPercentageValidity(errorPercent, "Error percentage must be between 0 and 100."); this.errorPercent = errorPercent; } private NetworkBehavior(Random random); static NetworkBehavior create(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static NetworkBehavior create(Random random); void setDelay(long amount, TimeUnit unit); long delay(TimeUnit unit); void setVariancePercent(int variancePercent); int variancePercent(); void setFailurePercent(int failurePercent); int failurePercent(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. void setFailureException(Throwable exception); Throwable failureException(); int errorPercent(); void setErrorPercent(int errorPercent); @SuppressWarnings("ConstantConditions") // Guarding API nullability. void setErrorFactory(Callable<Response<?>> errorFactory); Response<?> createErrorResponse(); boolean calculateIsFailure(); boolean calculateIsError(); long calculateDelay(TimeUnit unit); }### Answer:
@Test public void errorRestrictsRange() { try { behavior.setErrorPercent(-13); fail(); } catch (IllegalArgumentException e) { assertThat(e).hasMessage("Error percentage must be between 0 and 100."); } try { behavior.setErrorPercent(174); fail(); } catch (IllegalArgumentException e) { assertThat(e).hasMessage("Error percentage must be between 0 and 100."); } } |
### Question:
NetworkBehavior { @SuppressWarnings("ConstantConditions") public void setErrorFactory(Callable<Response<?>> errorFactory) { if (errorFactory == null) { throw new NullPointerException("errorFactory == null"); } this.errorFactory = errorFactory; } private NetworkBehavior(Random random); static NetworkBehavior create(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static NetworkBehavior create(Random random); void setDelay(long amount, TimeUnit unit); long delay(TimeUnit unit); void setVariancePercent(int variancePercent); int variancePercent(); void setFailurePercent(int failurePercent); int failurePercent(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. void setFailureException(Throwable exception); Throwable failureException(); int errorPercent(); void setErrorPercent(int errorPercent); @SuppressWarnings("ConstantConditions") // Guarding API nullability. void setErrorFactory(Callable<Response<?>> errorFactory); Response<?> createErrorResponse(); boolean calculateIsFailure(); boolean calculateIsError(); long calculateDelay(TimeUnit unit); }### Answer:
@Test public void errorFactoryIsNotNull() { try { behavior.setErrorFactory(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("errorFactory == null"); } } |
### Question:
MockRetrofit { public Retrofit retrofit() { return retrofit; } MockRetrofit(Retrofit retrofit, NetworkBehavior behavior, ExecutorService executor); Retrofit retrofit(); NetworkBehavior networkBehavior(); Executor backgroundExecutor(); @SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety. BehaviorDelegate<T> create(Class<T> service); }### Answer:
@Test public void retrofitPropagated() { MockRetrofit mockRetrofit = new MockRetrofit.Builder(retrofit).build(); assertThat(mockRetrofit.retrofit()).isSameAs(retrofit); } |
### Question:
MockRetrofit { public NetworkBehavior networkBehavior() { return behavior; } MockRetrofit(Retrofit retrofit, NetworkBehavior behavior, ExecutorService executor); Retrofit retrofit(); NetworkBehavior networkBehavior(); Executor backgroundExecutor(); @SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety. BehaviorDelegate<T> create(Class<T> service); }### Answer:
@Test public void networkBehaviorNullThrows() { MockRetrofit.Builder builder = new MockRetrofit.Builder(retrofit); try { builder.networkBehavior(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("behavior == null"); } }
@Test public void networkBehaviorDefault() { MockRetrofit mockRetrofit = new MockRetrofit.Builder(retrofit).build(); assertThat(mockRetrofit.networkBehavior()).isNotNull(); }
@Test public void networkBehaviorPropagated() { MockRetrofit mockRetrofit = new MockRetrofit.Builder(retrofit).networkBehavior(behavior).build(); assertThat(mockRetrofit.networkBehavior()).isSameAs(behavior); } |
### Question:
MockRetrofit { public Executor backgroundExecutor() { return executor; } MockRetrofit(Retrofit retrofit, NetworkBehavior behavior, ExecutorService executor); Retrofit retrofit(); NetworkBehavior networkBehavior(); Executor backgroundExecutor(); @SuppressWarnings("unchecked") // Single-interface proxy creation guarded by parameter safety. BehaviorDelegate<T> create(Class<T> service); }### Answer:
@Test public void backgroundExecutorNullThrows() { MockRetrofit.Builder builder = new MockRetrofit.Builder(retrofit); try { builder.backgroundExecutor(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("executor == null"); } }
@Test public void backgroundExecutorDefault() { MockRetrofit mockRetrofit = new MockRetrofit.Builder(retrofit).build(); assertThat(mockRetrofit.backgroundExecutor()).isNotNull(); }
@Test public void backgroundExecutorPropagated() { MockRetrofit mockRetrofit = new MockRetrofit.Builder(retrofit).backgroundExecutor(executor).build(); assertThat(mockRetrofit.backgroundExecutor()).isSameAs(executor); } |
### Question:
Result { @SuppressWarnings("ConstantConditions") public static <T> Result<T> response(Response<T> response) { if (response == null) throw new NullPointerException("response == null"); return new Result<>(response, null); } private Result(@Nullable Response<T> response, @Nullable Throwable error); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static Result<T> error(Throwable error); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static Result<T> response(Response<T> response); @Nullable Response<T> response(); @Nullable Throwable error(); boolean isError(); }### Answer:
@Test public void response() { Response<String> response = Response.success("Hi"); Result<String> result = Result.response(response); assertThat(result.isError()).isFalse(); assertThat(result.error()).isNull(); assertThat(result.response()).isSameAs(response); }
@Test public void nullResponseThrows() { try { Result.response(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("response == null"); } } |
### Question:
Calls { public static <T> Call<T> defer(Callable<Call<T>> callable) { return new DeferredCall<>(callable); } private Calls(); static Call<T> defer(Callable<Call<T>> callable); static Call<T> response(@Nullable T successValue); static Call<T> response(Response<T> response); static Call<T> failure(IOException failure); static Call<T> failure(Throwable failure); }### Answer:
@Test public void deferredThrowExecute() throws IOException { final IOException failure = new IOException("Hey"); Call<Object> failing = Calls.defer( () -> { throw failure; }); try { failing.execute(); fail(); } catch (IOException e) { assertSame(failure, e); } }
@Test public void deferredThrowEnqueue() { final IOException failure = new IOException("Hey"); Call<Object> failing = Calls.defer( () -> { throw failure; }); final AtomicReference<Throwable> failureRef = new AtomicReference<>(); failing.enqueue( new Callback<Object>() { @Override public void onResponse(Call<Object> call, Response<Object> response) { fail(); } @Override public void onFailure(Call<Object> call, Throwable t) { failureRef.set(t); } }); assertSame(failure, failureRef.get()); } |
### Question:
Result { @SuppressWarnings("ConstantConditions") public static <T> Result<T> error(Throwable error) { if (error == null) throw new NullPointerException("error == null"); return new Result<>(null, error); } private Result(@Nullable Response<T> response, @Nullable Throwable error); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static Result<T> error(Throwable error); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static Result<T> response(Response<T> response); @Nullable Response<T> response(); @Nullable Throwable error(); boolean isError(); }### Answer:
@Test public void error() { Throwable error = new IOException(); Result<Object> result = Result.error(error); assertThat(result.isError()).isTrue(); assertThat(result.error()).isSameAs(error); assertThat(result.response()).isNull(); }
@Test public void nullErrorThrows() { try { Result.error(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("error == null"); } } |
### Question:
RxJava2CallAdapterFactory extends CallAdapter.Factory { @SuppressWarnings("ConstantConditions") public static RxJava2CallAdapterFactory createWithScheduler(Scheduler scheduler) { if (scheduler == null) throw new NullPointerException("scheduler == null"); return new RxJava2CallAdapterFactory(scheduler, false); } private RxJava2CallAdapterFactory(@Nullable Scheduler scheduler, boolean isAsync); static RxJava2CallAdapterFactory create(); static RxJava2CallAdapterFactory createAsync(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static RxJava2CallAdapterFactory createWithScheduler(Scheduler scheduler); @Override @Nullable CallAdapter<?, ?> get(
Type returnType, Annotation[] annotations, Retrofit retrofit); }### Answer:
@Test public void nullSchedulerThrows() { try { RxJava2CallAdapterFactory.createWithScheduler(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("scheduler == null"); } } |
### Question:
JaxbConverterFactory extends Converter.Factory { public static JaxbConverterFactory create() { return new JaxbConverterFactory(null); } private JaxbConverterFactory(@Nullable JAXBContext context); static JaxbConverterFactory create(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static JaxbConverterFactory create(JAXBContext context); @Override @Nullable Converter<?, RequestBody> requestBodyConverter(
Type type,
Annotation[] parameterAnnotations,
Annotation[] methodAnnotations,
Retrofit retrofit); @Override @Nullable Converter<ResponseBody, ?> responseBodyConverter(
Type type, Annotation[] annotations, Retrofit retrofit); }### Answer:
@Test public void userSuppliedJaxbContext() throws Exception { JAXBContext context = JAXBContext.newInstance(Contact.class); JaxbConverterFactory factory = JaxbConverterFactory.create(context); Retrofit retrofit = new Retrofit.Builder().baseUrl(server.url("/")).addConverterFactory(factory).build(); service = retrofit.create(Service.class); server.enqueue(new MockResponse()); Call<Void> call = service.postXml(SAMPLE_CONTACT); call.execute(); RecordedRequest request = server.takeRequest(); assertThat(request.getHeader("Content-Type")).isEqualTo("application/xml; charset=utf-8"); assertThat(request.getBody().readUtf8()).isEqualTo(SAMPLE_CONTACT_XML); } |
### Question:
MoshiConverterFactory extends Converter.Factory { public MoshiConverterFactory asLenient() { return new MoshiConverterFactory(moshi, true, failOnUnknown, serializeNulls); } private MoshiConverterFactory(
Moshi moshi, boolean lenient, boolean failOnUnknown, boolean serializeNulls); static MoshiConverterFactory create(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static MoshiConverterFactory create(Moshi moshi); MoshiConverterFactory asLenient(); MoshiConverterFactory failOnUnknown(); MoshiConverterFactory withNullSerialization(); @Override Converter<ResponseBody, ?> responseBodyConverter(
Type type, Annotation[] annotations, Retrofit retrofit); @Override Converter<?, RequestBody> requestBodyConverter(
Type type,
Annotation[] parameterAnnotations,
Annotation[] methodAnnotations,
Retrofit retrofit); }### Answer:
@Test public void asLenient() throws IOException, InterruptedException { MockResponse malformedResponse = new MockResponse().setBody("{\"theName\":value}"); server.enqueue(malformedResponse); server.enqueue(malformedResponse); Call<AnImplementation> call = service.anImplementation(new AnImplementation("value")); try { call.execute(); fail(); } catch (IOException e) { assertEquals( e.getMessage(), "Use JsonReader.setLenient(true) to accept malformed JSON at path $.theName"); } Call<AnImplementation> call2 = serviceLenient.anImplementation(new AnImplementation("value")); Response<AnImplementation> response = call2.execute(); AnImplementation body = response.body(); assertThat(body.theName).isEqualTo("value"); } |
### Question:
RxJavaCallAdapterFactory extends CallAdapter.Factory { @SuppressWarnings("ConstantConditions") public static RxJavaCallAdapterFactory createWithScheduler(Scheduler scheduler) { if (scheduler == null) throw new NullPointerException("scheduler == null"); return new RxJavaCallAdapterFactory(scheduler, false); } private RxJavaCallAdapterFactory(@Nullable Scheduler scheduler, boolean isAsync); static RxJavaCallAdapterFactory create(); static RxJavaCallAdapterFactory createAsync(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static RxJavaCallAdapterFactory createWithScheduler(Scheduler scheduler); @Override @Nullable CallAdapter<?, ?> get(
Type returnType, Annotation[] annotations, Retrofit retrofit); }### Answer:
@Test public void nullSchedulerThrows() { try { RxJavaCallAdapterFactory.createWithScheduler(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("scheduler == null"); } } |
### Question:
Result { @SuppressWarnings("ConstantConditions") public static <T> Result<T> response(Response<T> response) { if (response == null) throw new NullPointerException("response == null"); return new Result<>(response, null); } private Result(@Nullable Response<T> response, @Nullable Throwable error); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static Result<T> error(Throwable error); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static Result<T> response(Response<T> response); @Nullable Response<T> response(); @Nullable Throwable error(); boolean isError(); @Override String toString(); }### Answer:
@Test public void response() { Response<String> response = Response.success("Hi"); Result<String> result = Result.response(response); assertThat(result.isError()).isFalse(); assertThat(result.error()).isNull(); assertThat(result.response()).isSameAs(response); }
@Test public void nullResponseThrows() { try { Result.response(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("response == null"); } } |
### Question:
MoshiConverterFactory extends Converter.Factory { public MoshiConverterFactory failOnUnknown() { return new MoshiConverterFactory(moshi, lenient, true, serializeNulls); } private MoshiConverterFactory(
Moshi moshi, boolean lenient, boolean failOnUnknown, boolean serializeNulls); static MoshiConverterFactory create(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static MoshiConverterFactory create(Moshi moshi); MoshiConverterFactory asLenient(); MoshiConverterFactory failOnUnknown(); MoshiConverterFactory withNullSerialization(); @Override Converter<ResponseBody, ?> responseBodyConverter(
Type type, Annotation[] annotations, Retrofit retrofit); @Override Converter<?, RequestBody> requestBodyConverter(
Type type,
Annotation[] parameterAnnotations,
Annotation[] methodAnnotations,
Retrofit retrofit); }### Answer:
@Test public void failOnUnknown() throws IOException, InterruptedException { server.enqueue(new MockResponse().setBody("{\"taco\":\"delicious\"}")); Call<AnImplementation> call = serviceFailOnUnknown.anImplementation(new AnImplementation(null)); try { call.execute(); fail(); } catch (JsonDataException e) { assertThat(e).hasMessage("Cannot skip unexpected NAME at $."); } } |
### Question:
Result { @SuppressWarnings("ConstantConditions") public static <T> Result<T> error(Throwable error) { if (error == null) throw new NullPointerException("error == null"); return new Result<>(null, error); } private Result(@Nullable Response<T> response, @Nullable Throwable error); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static Result<T> error(Throwable error); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static Result<T> response(Response<T> response); @Nullable Response<T> response(); @Nullable Throwable error(); boolean isError(); @Override String toString(); }### Answer:
@Test public void error() { Throwable error = new IOException(); Result<Object> result = Result.error(error); assertThat(result.isError()).isTrue(); assertThat(result.error()).isSameAs(error); assertThat(result.response()).isNull(); }
@Test public void nullErrorThrows() { try { Result.error(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("error == null"); } } |
### Question:
GuavaOptionalConverterFactory extends Converter.Factory { public static GuavaOptionalConverterFactory create() { return new GuavaOptionalConverterFactory(); } private GuavaOptionalConverterFactory(); static GuavaOptionalConverterFactory create(); @Override @Nullable Converter<ResponseBody, ?> responseBodyConverter(
Type type, Annotation[] annotations, Retrofit retrofit); }### Answer:
@Test public void delegates() throws IOException { final Object object = new Object(); Retrofit retrofit = new Retrofit.Builder() .baseUrl(server.url("/")) .addConverterFactory( new Converter.Factory() { @Nullable @Override public Converter<ResponseBody, Object> responseBodyConverter( Type type, Annotation[] annotations, Retrofit retrofit) { if (getRawType(type) != Object.class) { return null; } return value -> object; } }) .addConverterFactory(GuavaOptionalConverterFactory.create()) .build(); server.enqueue(new MockResponse()); Service service = retrofit.create(Service.class); Optional<Object> optional = service.optional().execute().body(); assertThat(optional).isNotNull(); assertThat(optional.get()).isSameAs(object); } |
### Question:
Response { public static <T> Response<T> success(@Nullable T body) { return success( body, new okhttp3.Response.Builder() .code(200) .message("OK") .protocol(Protocol.HTTP_1_1) .request(new Request.Builder().url("http: .build()); } private Response(
okhttp3.Response rawResponse, @Nullable T body, @Nullable ResponseBody errorBody); static Response<T> success(@Nullable T body); static Response<T> success(int code, @Nullable T body); static Response<T> success(@Nullable T body, Headers headers); static Response<T> success(@Nullable T body, okhttp3.Response rawResponse); static Response<T> error(int code, ResponseBody body); static Response<T> error(ResponseBody body, okhttp3.Response rawResponse); okhttp3.Response raw(); int code(); String message(); Headers headers(); boolean isSuccessful(); @Nullable T body(); @Nullable ResponseBody errorBody(); @Override String toString(); }### Answer:
@Test public void success() { Object body = new Object(); Response<Object> response = Response.success(body); assertThat(response.raw()).isNotNull(); assertThat(response.code()).isEqualTo(200); assertThat(response.message()).isEqualTo("OK"); assertThat(response.headers().size()).isZero(); assertThat(response.isSuccessful()).isTrue(); assertThat(response.body()).isSameAs(body); assertThat(response.errorBody()).isNull(); }
@Test public void successWithNullHeadersThrows() { try { Response.success("", (okhttp3.Headers) null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("headers == null"); } }
@Test public void successWithNullRawResponseThrows() { try { Response.success("", (okhttp3.Response) null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("rawResponse == null"); } }
@Test public void successWithErrorRawResponseThrows() { try { Response.success("", errorResponse); fail(); } catch (IllegalArgumentException e) { assertThat(e).hasMessage("rawResponse must be successful response"); } } |
### Question:
RxJava3CallAdapterFactory extends CallAdapter.Factory { @SuppressWarnings("ConstantConditions") public static RxJava3CallAdapterFactory createWithScheduler(Scheduler scheduler) { if (scheduler == null) throw new NullPointerException("scheduler == null"); return new RxJava3CallAdapterFactory(scheduler, false); } private RxJava3CallAdapterFactory(@Nullable Scheduler scheduler, boolean isAsync); static RxJava3CallAdapterFactory create(); static RxJava3CallAdapterFactory createSynchronous(); @SuppressWarnings("ConstantConditions") // Guarding API nullability. static RxJava3CallAdapterFactory createWithScheduler(Scheduler scheduler); @Override @Nullable CallAdapter<?, ?> get(
Type returnType, Annotation[] annotations, Retrofit retrofit); }### Answer:
@Test public void nullSchedulerThrows() { try { RxJava3CallAdapterFactory.createWithScheduler(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("scheduler == null"); } } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.