Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
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(); }
@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); }
SelectorImpl extends Thread implements com.sun.corba.ee.spi.transport.Selector { void runSelectionLoopOnce() throws IOException { beginSelect(); int n = 0; handleDeferredRegistrations(); enableInterestOps(); try { n = selector.select(timeout); } catch (IOException e) { display( "Exception in select:", e ) ; } if (closed) { selector.close(); selectorClosed(); return; } Iterator<SelectionKey> iterator = selector.selectedKeys().iterator(); selectResult(iterator.hasNext(), n); while (iterator.hasNext()) { SelectionKey selectionKey = iterator.next(); iterator.remove(); if (selectionKey.isValid()) { EventHandler eventHandler = (EventHandler)selectionKey.attachment(); try { eventHandler.handleEvent(); if (lastActivityTimers.containsKey(eventHandler)) lastActivityTimers.put(eventHandler, timer.getCurrentTime()); } catch (Throwable t) { wrapper.exceptionInSelector( t, eventHandler ) ; } } else { wrapper.canceledSelectionKey( selectionKey ) ; skippingEventForCancelledKey(); } } long currentTime = timer.getCurrentTime(); for (EventHandler handler : lastActivityTimers.keySet()) { long elapsedTime = currentTime - lastActivityTimers.get(handler); ((Timeoutable) handler).checkForTimeout(elapsedTime); } endSelect(); } 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(); }
@Test public void whenIoAvailable_dispatchToEventHandler() throws IOException { registerEventHandler(); selectorStub.setReady(channel, SelectionKey.OP_READ); selector.runSelectionLoopOnce(); assertEquals(1, eventHandler.numInvocations); } @Test public void whenEventTimesOut_reportTimeout() throws IOException { registerEventHandler(); timer.setCurrentTime(1000); selector.runSelectionLoopOnce(); assertTrue(eventHandler.timeout); } @Test public void whenEventHappens_resetTheTimer() throws IOException { registerEventHandler(); timer.setCurrentTime(1000); selectorStub.setReady(channel, SelectionKey.OP_READ); selector.runSelectionLoopOnce(); assertFalse(eventHandler.timeout); }
ConnectionImpl extends EventHandlerBase implements Connection, Work { public SocketChannel getSocketChannel() { return socketChannel; } ConnectionImpl(ORB orb); protected ConnectionImpl(ORB orb, boolean useSelectThreadToWait, boolean useWorkerThread); private ConnectionImpl(ORB orb, ContactInfo contactInfo, boolean useSelectThreadToWait, boolean useWorkerThread, String socketType, String hostname, int port); ConnectionImpl(ORB orb, ContactInfo contactInfo, String socketType, String hostname, int port); private ConnectionImpl(ORB orb, Acceptor acceptor, Socket socket, boolean useSelectThreadToWait, boolean useWorkerThread); ConnectionImpl(ORB orb, Acceptor acceptor, Socket socket); SocketChannel getSocketChannel(); boolean shouldRegisterReadEvent(); boolean shouldRegisterServerReadEvent(); boolean read(); boolean hasSocketChannel(); @Transport void write(ByteBuffer byteBuffer); @Transport synchronized void close(); @Transport void closeConnectionResources(); Acceptor getAcceptor(); ContactInfo getContactInfo(); EventHandler getEventHandler(); boolean isServer(); boolean isClosed(); boolean isBusy(); long getTimeStamp(); void setTimeStamp(long time); void setState(String stateString); @Transport void writeLock(); @Transport void writeUnlock(); void sendWithoutLock(CDROutputObject outputObject); void registerWaiter(MessageMediator messageMediator); void unregisterWaiter(MessageMediator messageMediator); CDRInputObject waitForResponse(MessageMediator messageMediator); void setConnectionCache(ConnectionCache connectionCache); ConnectionCache getConnectionCache(); @Override void setUseSelectThreadToWait(boolean x); SelectableChannel getChannel(); int getInterestOps(); Connection getConnection(); String getName(); @Transport void doWork(); void setEnqueueTime(long timeInMillis); long getEnqueueTime(); ResponseWaitingRoom getResponseWaitingRoom(); void serverRequestMapPut(int reqId, MessageMediator messageMediator); MessageMediator serverRequestMapGet(int reqId); void serverRequestMapRemove(int reqId); Queue<MessageMediator> getFragmentList(RequestId corbaRequestId); void removeFragmentList(RequestId corbaRequestId); java.net.Socket getSocket(); synchronized void serverRequestProcessingBegins(); synchronized void serverRequestProcessingEnds(); int getNextRequestId(); ORB getBroker(); synchronized CodeSetComponentInfo.CodeSetContext getCodeSetContext(); synchronized void setCodeSetContext(CodeSetComponentInfo.CodeSetContext csc); MessageMediator clientRequestMapGet(int requestId); void clientReply_1_1_Put(MessageMediator x); MessageMediator clientReply_1_1_Get(); void clientReply_1_1_Remove(); void serverRequest_1_1_Put(MessageMediator x); MessageMediator serverRequest_1_1_Get(); void serverRequest_1_1_Remove(); synchronized boolean isPostInitialContexts(); synchronized void setPostInitialContexts(); @Transport void purgeCalls(SystemException systemException, boolean die, boolean lockHeld); void sendCloseConnection(GIOPVersion giopVersion); void sendMessageError(GIOPVersion giopVersion); void sendCancelRequest(GIOPVersion giopVersion, int requestId); void sendCancelRequestWithLock(GIOPVersion giopVersion, int requestId); final void setCodeBaseIOR(IOR ior); final IOR getCodeBaseIOR(); final CodeBase getCodeBase(); ByteBuffer extractAndProcessMessages(ByteBuffer byteBuffer); @Override String toString(); }
@Test(expected = RuntimeException.class) public void whenNioConfigureBlockingFails_throwException() throws IOException { SocketChannelFake socketChannel = getSocketChannel(); socketChannel.setFailToConfigureBlocking(); useNio(); }
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(); }
@Test public void whenForeignProfileOrbVersion_isLocalReturnsFalse() throws Exception { setOrbVersion(ORBVersionImpl.FOREIGN); assertThat(iiopProfile.isLocal(), is(false)); }
AnyImpl extends Any { public TypeCode type() { return typeCode; } AnyImpl(ORB orb); AnyImpl(ORB orb, Any obj); TypeCode type(); void type(TypeCode tc); @DynamicType boolean equal(Any otherAny); org.omg.CORBA.portable.OutputStream create_output_stream(); @DynamicType org.omg.CORBA.portable.InputStream create_input_stream(); @DynamicType void read_value(org.omg.CORBA.portable.InputStream in, TypeCode tc); @DynamicType void write_value(OutputStream out); @Override void insert_Streamable(Streamable s); @Override Streamable extract_Streamable(); void insert_short(short s); short extract_short(); void insert_long(int l); int extract_long(); void insert_ushort(short s); short extract_ushort(); void insert_ulong(int l); int extract_ulong(); void insert_float(float f); float extract_float(); void insert_double(double d); double extract_double(); void insert_longlong(long l); long extract_longlong(); void insert_ulonglong(long l); long extract_ulonglong(); void insert_boolean(boolean b); boolean extract_boolean(); void insert_char(char c); char extract_char(); void insert_wchar(char c); char extract_wchar(); void insert_octet(byte b); byte extract_octet(); void insert_string(String s); String extract_string(); void insert_wstring(String s); String extract_wstring(); void insert_any(Any a); Any extract_any(); void insert_Object(org.omg.CORBA.Object o); void insert_Object(org.omg.CORBA.Object o, TypeCode tc); org.omg.CORBA.Object extract_Object(); void insert_TypeCode(TypeCode tc); TypeCode extract_TypeCode(); @SuppressWarnings({"deprecation"}) @Override void insert_Principal(org.omg.CORBA.Principal p); @SuppressWarnings({"deprecation"}) @Override org.omg.CORBA.Principal extract_Principal(); Serializable extract_Value(); void insert_Value(Serializable v); void insert_Value(Serializable v, org.omg.CORBA.TypeCode t); @Override void insert_fixed(java.math.BigDecimal value); @Override void insert_fixed(java.math.BigDecimal value, org.omg.CORBA.TypeCode type); @Override java.math.BigDecimal extract_fixed(); @DynamicType static TypeCode createTypeCodeForClass(java.lang.Class c, ORB tcORB); static Any extractAnyFromStream(TypeCode memberType, InputStream input, ORB orb); boolean isInitialized(); }
@Test public void whenAnyCreated_typeIsNull() { assertEquals(TCKind.tk_null, any.type().kind()); }
AnyImpl extends Any { public byte extract_octet() { checkExtractBadOperation( TCKind._tk_octet ) ; return (byte)value; } AnyImpl(ORB orb); AnyImpl(ORB orb, Any obj); TypeCode type(); void type(TypeCode tc); @DynamicType boolean equal(Any otherAny); org.omg.CORBA.portable.OutputStream create_output_stream(); @DynamicType org.omg.CORBA.portable.InputStream create_input_stream(); @DynamicType void read_value(org.omg.CORBA.portable.InputStream in, TypeCode tc); @DynamicType void write_value(OutputStream out); @Override void insert_Streamable(Streamable s); @Override Streamable extract_Streamable(); void insert_short(short s); short extract_short(); void insert_long(int l); int extract_long(); void insert_ushort(short s); short extract_ushort(); void insert_ulong(int l); int extract_ulong(); void insert_float(float f); float extract_float(); void insert_double(double d); double extract_double(); void insert_longlong(long l); long extract_longlong(); void insert_ulonglong(long l); long extract_ulonglong(); void insert_boolean(boolean b); boolean extract_boolean(); void insert_char(char c); char extract_char(); void insert_wchar(char c); char extract_wchar(); void insert_octet(byte b); byte extract_octet(); void insert_string(String s); String extract_string(); void insert_wstring(String s); String extract_wstring(); void insert_any(Any a); Any extract_any(); void insert_Object(org.omg.CORBA.Object o); void insert_Object(org.omg.CORBA.Object o, TypeCode tc); org.omg.CORBA.Object extract_Object(); void insert_TypeCode(TypeCode tc); TypeCode extract_TypeCode(); @SuppressWarnings({"deprecation"}) @Override void insert_Principal(org.omg.CORBA.Principal p); @SuppressWarnings({"deprecation"}) @Override org.omg.CORBA.Principal extract_Principal(); Serializable extract_Value(); void insert_Value(Serializable v); void insert_Value(Serializable v, org.omg.CORBA.TypeCode t); @Override void insert_fixed(java.math.BigDecimal value); @Override void insert_fixed(java.math.BigDecimal value, org.omg.CORBA.TypeCode type); @Override java.math.BigDecimal extract_fixed(); @DynamicType static TypeCode createTypeCodeForClass(java.lang.Class c, ORB tcORB); static Any extractAnyFromStream(TypeCode memberType, InputStream input, ORB orb); boolean isInitialized(); }
@Test(expected = BAD_OPERATION.class) public void whenReadingUninitializedAny_throwException() { any.extract_octet(); }
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(); }
@Test public void dynamicStubFactory_createsDynamicStubs() throws Exception { assertThat(PresentationDefaults.getDynamicStubFactoryFactory().createsDynamicStubs(), is(true)); }
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(); }
@Test public void staticStubFactory_doesNotCreateDynamicStubs() throws Exception { assertThat(PresentationDefaults.getStaticStubFactoryFactory().createsDynamicStubs(), is(false)); }
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(); }
@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)); }
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); }
@Test public void readVersionFromDefaultPropertyFile() throws Exception { assertThat(Util.getVersion(), containsString("4.02")); } @Test public void readVersionFromUnnamedPropertyFile() throws Exception { assertThat(Util.getVersion(""), containsString("4.02")); }
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); }
@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")); }
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); }
@Test public void canRetrieveLatestAsmVersion() { assertThat(AsmClassFactory.getLatestVersion(), equalTo(Opcodes.ASM6)); }
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; }
@Test public void testGetProjectDirectory() { assertTrue(true); }
AdhocProject implements Project, FileOwnerQueryImplementation, ProjectConfiguration, ProjectActionPerformer, ActionProvider, LogicalViewProvider { @Override public Lookup getLookup() { return Lookups.fixed(this, aux, encodingQuery, ops, info, customizer); } 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; }
@Test public void testGetLookup() { assertNotNull(project.getLookup().lookup(Project.class)); assertNotNull(project.getLookup().lookup(AdhocProject.class)); assertNotNull(project.getLookup().lookup(ProjectInformation.class)); assertNotNull(project.getLookup().lookup(FileOwnerQueryImplementation.class)); assertNotNull(project.getLookup().lookup(ProjectConfiguration.class)); assertNotNull(project.getLookup().lookup(ProjectActionPerformer.class)); assertNotNull(project.getLookup().lookup(ActionProvider.class)); assertNotNull(project.getLookup().lookup(LogicalViewProvider.class)); assertNotNull(project.getLookup().lookup(CustomizerProvider.class)); assertNotNull(project.getLookup().lookup(CopyOperationImplementation.class)); assertNotNull(project.getLookup().lookup(DeleteOperationImplementation.class)); assertNotNull(project.getLookup().lookup(MoveOperationImplementation.class)); } @Test public void testGetName() { assertEquals(name, project.getLookup().lookup(ProjectInformation.class).getName()); } @Test public void testGetProject() { assertSame(project, project.getLookup().lookup(ProjectInformation.class).getProject()); } @Test public void testConfiguration() { AuxiliaryProperties p = project.getLookup().lookup(AuxiliaryProperties.class); assertNotNull(p); String a = p.get("a", false); assertNull(a); a = p.get("a", true); assertNull(a); p.put("a", "shared", true); p.put("a", "unshared", false); assertEquals("shared", p.get("a", true)); assertEquals("unshared", p.get("a", false)); }
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; }
@Test public void testGetDisplayName() { assertEquals(name, project.getDisplayName()); }
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; }
@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()); }
AdhocProject implements Project, FileOwnerQueryImplementation, ProjectConfiguration, ProjectActionPerformer, ActionProvider, LogicalViewProvider { public List<Favorite> favorites() { List<Favorite> favorites = new ArrayList<>(); try { Preferences forProject = preferences(false); if (forProject != null) { String[] s = forProject.childrenNames(); for (String ch : s) { Preferences forFile = forProject.node(ch); if (forFile != null) { int val = forFile.getInt("value", 0); String name = forFile.get("name", null); if (val > 0 && name != null) { Favorite fav = new Favorite(val, name); favorites.add(fav); } } } } } catch (BackingStoreException ex) { Exceptions.printStackTrace(ex); } Collections.sort(favorites); return favorites; } 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; }
@Test public void testFavorites() { java.util.List<Favorite> favs = new ArrayList<>(); char[] chars = new char[]{'d', 'c', 'b', 'a'}; int ix = 1; for (char c : chars) { favs.add(new Favorite(ix *= 10, "foo/" + c)); } project.saveFavorites(favs); java.util.List<Favorite> nue = project.favorites(); assertEquals(new HashSet<>(favs), new HashSet<>(nue)); }
AdhocProject implements Project, FileOwnerQueryImplementation, ProjectConfiguration, ProjectActionPerformer, ActionProvider, LogicalViewProvider { @Override public Node findPath(Node node, Object o) { AdhocProjectNode view = logicalView == null ? null : logicalView.get(); if (view != null) { view.findPath(node, o); } return null; } 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; }
@Test public void testFindPath() { AdhocProjectNode pn = (AdhocProjectNode) project.createLogicalView(); assertNotNull(pn); Node[] nn = pn.getChildren().getNodes(true); assertNotNull(nn); assertEquals(3, nn.length); assertEquals("Favorites", nn[0].getName()); assertEquals("byType", nn[1].getName()); assertEquals("Sources", nn[2].getName()); Node[] sources = nn[2].getChildren().getNodes(true); assertNotNull(sources); assertEquals(10, sources.length); Node found = pn.findPath(pn, files[3]); assertNotNull(found); assertEquals(files[3], found.getLookup().lookup(DataObject.class).getPrimaryFile()); assertTrue(isAncestor(pn, found)); FilterNode fn = new FilterNode(pn); found = pn.findPath(fn, files[3]); assertNotNull(found); assertEquals(files[3], found.getLookup().lookup(DataObject.class).getPrimaryFile()); assertTrue(isAncestor(pn, found)); }
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); }
@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); }
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; }
@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); }
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; }
@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); }
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; }
@Test public void testExtractShardId() { long id = IdentityGenerator.doGenerate(SHARD_ID, TIME_DIFF, 10); byte shardId = IdentityGenerator.extractShardId(id); assertEquals(SHARD_ID, shardId); }
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; }
@Test public void testExtractInstant() { long id = IdentityGenerator.doGenerate(SHARD_ID, TIME_DIFF, 10); Instant instant = IdentityGenerator.extractInstant(id); assertEquals(INSTANT.getEpochSecond(), instant.getEpochSecond()); }
SceneStack implements Iterable<Scene> { boolean isEmpty() { return stack.isEmpty(); } SceneStack(@NonNull Callback callback); @Override Iterator<Scene> iterator(); }
@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()); }
SceneStack implements Iterable<Scene> { int size() { return stack.size(); } SceneStack(@NonNull Callback callback); @Override Iterator<Scene> iterator(); }
@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()); }
SceneStack implements Iterable<Scene> { @Nullable Scene peek() { return stack.peekFirst(); } SceneStack(@NonNull Callback callback); @Override Iterator<Scene> iterator(); }
@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()); }
SceneStack implements Iterable<Scene> { @Nullable Scene tail() { return stack.peekLast(); } SceneStack(@NonNull Callback callback); @Override Iterator<Scene> iterator(); }
@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()); }
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); }
@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()); }
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); }
@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()); }
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); }
@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()); }
Scene { public void recreateView() { if (view == null) { return; } boolean resumed = false; boolean started = false; int index = -1; if (lifecycleState.isResumed()) { resumed = true; pause(); } if (lifecycleState.isStarted()) { started = true; stop(); } if (lifecycleState.isViewAttached()) { index = stage.getContainer().indexOfChild(view); if (DEBUG) { if (index == -1) { throw new IllegalStateException("The view is not attached"); } } detachView(stage.getContainer(), true, true); } else { destroyView(true); } inflate(stage.getContainer()); if (index != -1) { attachView(stage.getContainer(), index); } if (started) { start(); } if (resumed) { resume(); } } @Nullable final Stage getStage(); @NonNull final LifecycleState getLifecycleState(); final int getId(); void setArgs(@Nullable Bundle args); void setTag(@Nullable String tag); @Nullable final String getTag(); final void setWillRetainView(boolean willRetainView); final boolean willRetainView(); final void setOpacity(@Opacity int opacity); @Opacity final int getOpacity(); final void setTheme(int theme); final int getTheme(); final void setTarget(Scene scene); @Nullable final Scene getTarget(); @Nullable View getView(); void addLifecycleListener(@NonNull LifecycleListener lifecycleListener); void removeLifecycleListener(@NonNull LifecycleListener lifecycleListener); boolean willRecreate(); void pop(); void requestFocus(); boolean handleBack(); @Nullable Scene findSceneById(int sceneId); @NonNull Director hireChildDirector(); boolean willDestroyActivity(); @Nullable final Context getContext(); @Nullable final Activity getActivity(); @Nullable final Application getApplication(); void startActivity(@NonNull Intent intent); @RequiresApi(Build.VERSION_CODES.JELLY_BEAN) void startActivity(@NonNull Intent intent, @Nullable Bundle options); void startActivityForResult(Intent intent, int requestCode); @RequiresApi(Build.VERSION_CODES.JELLY_BEAN) void startActivityForResult(Intent intent, int requestCode, Bundle options); @CallSuper void onActivityResult(int requestCode, int resultCode, Intent data); void requestPermissions(@NonNull String[] permissions, int requestCode); @CallSuper void onRequestPermissionsResult( int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults); void recreateView(); @Override String toString(); static final int INVALID_ID; static final int TRANSPARENT; static final int TRANSLUCENT; static final int OPAQUE; }
@Test public void testRecreateView() { stage.start(); stage.resume(); Scene scene1 = new TestScene(); stage.pushScene(scene1); Scene scene2 = new TestScene(); stage.pushScene(scene2); assertEquals(true, scene2.getLifecycleState().isResumed()); int hashCode1 = scene2.getView().hashCode(); scene2.recreateView(); assertEquals(true, scene2.getLifecycleState().isResumed()); int hashCode2 = scene2.getView().hashCode(); assertNotEquals(hashCode1, hashCode2); }
Director implements Iterable<Stage> { @Nullable public Scene findSceneById(int sceneId) { for(int i = 0, n = stageMap.size(); i < n; i++) { Stage stage = stageMap.valueAt(i); Scene result = stage.findSceneById(sceneId); if (result != null) { return result; } } return null; } 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); }
@Test public void testFindSceneById() { 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); assertEquals(scene1, director.findSceneById(1)); assertEquals(scene2, director.findSceneById(2)); assertEquals(scene3, director.findSceneById(3)); assertEquals(scene4, director.findSceneById(4)); assertEquals(scene5, director.findSceneById(5)); assertEquals(scene6, director.findSceneById(6)); assertEquals(null, director.findSceneById(7)); }
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); }
@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()); }
SpydraArgument { public static SpydraArgument merge(SpydraArgument first, SpydraArgument second) { if (first == null) { return second; } else if (second == null) { return first; } SpydraArgument merged = new SpydraArgument(); if (second.clientId.isPresent()) { merged.clientId = second.clientId; } else { merged.clientId = first.clientId; } if (second.logBucket.isPresent()) { merged.logBucket = second.logBucket; } else { merged.logBucket = first.logBucket; } if (second.metricClass.isPresent()) { merged.metricClass = second.metricClass; } else { merged.metricClass = first.metricClass; } if (second.clusterType.isPresent()) { merged.clusterType = second.clusterType; } else { merged.clusterType = first.clusterType; } if (second.historyTimeout.isPresent()) { merged.historyTimeout = second.historyTimeout; } else { merged.historyTimeout = first.historyTimeout; } if (second.autoScaler.isPresent()) { merged.autoScaler = second.autoScaler; } else if (first.autoScaler.isPresent()) { merged.autoScaler = first.autoScaler; } if (second.dryRun.isPresent()) { merged.dryRun = second.dryRun; } else { merged.dryRun = first.dryRun; } if (second.jobType.isPresent()) { merged.jobType = second.jobType; } else { merged.jobType = first.jobType; } if (second.cluster.name.isPresent()) { merged.cluster.name = second.cluster.name; } else { merged.cluster.name = first.cluster.name; } merged.cluster.options.putAll(first.cluster.options); mergeOptions(merged.cluster.options, second.cluster.options); merged.submit.options.putAll(first.submit.options); mergeOptions(merged.submit.options, second.submit.options); if (second.submit.jobArgs.isPresent()) { merged.submit.jobArgs = second.submit.jobArgs; } else { merged.submit.jobArgs = first.submit.jobArgs; } if (second.submit.pyFile.isPresent()) { merged.submit.pyFile = second.submit.pyFile; } else { merged.submit.pyFile = first.submit.pyFile; } if (second.pooling.isPresent()) { merged.pooling = second.pooling; } else { merged.pooling = first.pooling; } if (second.region.isPresent()) { merged.region = second.region; } else { merged.region = first.region; } return merged; } static SpydraArgument merge(SpydraArgument first, SpydraArgument second); void replacePlaceholders(); static void addOption(Map<String, String> options, String key, String value); Properties clusterProperties(); Properties submitProperties(); String getClientId(); String getLogBucket(); String getMetricClass(); String getRegion(); ClusterType getClusterType(); Integer getHistoryTimeout(); Boolean isDryRun(); String getJobType(); Cluster getCluster(); Submit getSubmit(); AutoScaler getAutoScaler(); Pooling getPooling(); void setPooling(Integer limit, Duration maxAge); void setPooling(Pooling pooling); boolean isPoolingEnabled(); void setClientId(String clientId); void setLogBucket(String logBucket); void setMetricClass(String metricClass); void setRegion(String region); void setClusterType(ClusterType clusterType); void setHistoryTimeout(Integer historyTimeout); void setDryRun(Boolean dryRun); void setCluster(Cluster cluster); void setSubmit(Submit submit); void setJobType(String jobType); void setAutoScaler(AutoScaler autoScaler); void setAutoScaler(Double factor, Integer interval, Integer max); void setAutoScaler(Double factor, Integer interval, Integer max, Optional<Integer> downscaleTimeout); static final String OPTION_JAR; static final String OPTION_JARS; static final String OPTION_CLASS; static final String OPTION_PROPERTIES; static final String OPTION_FILES; static final String OPTION_PROJECT; static final String OPTION_REGION; static final String OPTION_ZONE; static final String OPTION_METADATA; static final String OPTION_CLUSTER; static final String OPTION_INIT_ACTIONS; static final String OPTION_SCOPES; static final String OPTION_NETWORK; static final String OPTION_SUBNET; static final String OPTION_WORKER_MACHINE_TYPE; static final String OPTION_MASTER_MACHINE_TYPE; static final String OPTION_NUM_WORKERS; static final String OPTION_LABELS; static final String OPTION_TAGS; static final String OPTION_ACCOUNT; static final String OPTION_SERVICE_ACCOUNT; static final String OPTION_JOB_ID; static final String OPTION_MAX_IDLE; static final String OPTIONS_FILTER; static final String OPTIONS_FILTER_LABEL_PREFIX; static final String JOB_TYPE_HADOOP; static final String JOB_TYPE_PYSPARK; static final String CLIENT_ID_PROPERTIES_PLACEHOLDER; static final String LOG_BUCKET_PROPERTIES_PLACEHOLDER; static final String UUID_PLACEHOLDER; static final String OPTION_DRYRUN; public Optional<String> clientId; public Optional<String> logBucket; public Optional<String> metricClass; public Optional<String> region; public Optional<ClusterType> clusterType; public Optional<Integer> historyTimeout; public Optional<Boolean> dryRun; public Optional<AutoScaler> autoScaler; public Optional<Pooling> pooling; public Cluster cluster; public Submit submit; public Optional<String> jobType; }
@Test public void testMergeEmptyArguments() { SpydraArgument first = new SpydraArgument(); SpydraArgument second = new SpydraArgument(); SpydraArgument merged = SpydraArgument.merge(first, second); Assert.assertNotNull(merged); }
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; }
@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); }
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; }
@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); }
HistoryLogUtils { public static Configuration generateHadoopConfig( String clientId, String username, String bucket) { Configuration cfg = new Configuration(false); cfg.addResource(HISTORY_LOG_CONFIG_NAME); cfg.reloadConfiguration(); cfg.set(SPYDRA_HISTORY_CLIENT_ID_PROPERTY, clientId); cfg.set(SPYDRA_HISTORY_USERNAME_PROPERTY, username); cfg.set(SPYDRA_HISTORY_BUCKET_PROPERTY, bucket); if (logger.isDebugEnabled()) { logger.debug("Dumping generated config to be applied for log/history tools"); logger.debug( StreamSupport.stream(cfg.spliterator(), false) .map(Object::toString) .collect(Collectors.joining("\n"))); } return cfg; } static Configuration generateHadoopConfig( String clientId, String username, String bucket); static Configuration generateHadoopConfig(String clientId, String bucket); static void dumpFullLogs(Configuration cfg, ApplicationId applicationId); static void dumpFullHistory(Configuration cfg, ApplicationId applicationId); static Optional<String> findHistoryFilePath( FileSystem fs, String historyDirPrefix, ApplicationId applicationId); static Optional<String> findHistoryFilePath( Iterator<LocatedFileStatus> listing, ApplicationId applicationId); static void startJhs(Configuration cfg); static void main(String[] args); static final String DEFAULT_USER_NAME; static final String HISTORY_LOG_CONFIG_NAME; static final String SPYDRA_HISTORY_CLIENT_ID_PROPERTY; static final String SPYDRA_HISTORY_USERNAME_PROPERTY; static final String SPYDRA_HISTORY_BUCKET_PROPERTY; }
@Test public void testGenerateHadoopConfig() throws Exception { Configuration cfg = HistoryLogUtils.generateHadoopConfig(DUMMY_CLIENT_ID, DUMMY_USER_NAME, DUMMY_BUCKET); checkPropertySubstitution(this.configWithoutSubstitute, cfg, YarnConfiguration.NM_REMOTE_APP_LOG_DIR, "gs: checkPropertySubstitution(this.configWithoutSubstitute, cfg, JHAdminConfig.MR_HISTORY_INTERMEDIATE_DONE_DIR, "gs: checkPropertySubstitution(this.configWithoutSubstitute, cfg, JHAdminConfig.MR_HISTORY_DONE_DIR, "gs: assertEquals("Sizes of configuration must not differ. Except for the user, client-id and bucket properties", cfg.size(), this.configWithoutSubstitute.size() + 3); }
HistoryLogUtils { public static Optional<String> findHistoryFilePath( FileSystem fs, String historyDirPrefix, ApplicationId applicationId) throws IOException, URISyntaxException { Path jhistPathPattern = new Path(historyDirPrefix); return findHistoryFilePath( new RemoteIteratorAdaptor<>(fs.listFiles(jhistPathPattern, true)), applicationId); } static Configuration generateHadoopConfig( String clientId, String username, String bucket); static Configuration generateHadoopConfig(String clientId, String bucket); static void dumpFullLogs(Configuration cfg, ApplicationId applicationId); static void dumpFullHistory(Configuration cfg, ApplicationId applicationId); static Optional<String> findHistoryFilePath( FileSystem fs, String historyDirPrefix, ApplicationId applicationId); static Optional<String> findHistoryFilePath( Iterator<LocatedFileStatus> listing, ApplicationId applicationId); static void startJhs(Configuration cfg); static void main(String[] args); static final String DEFAULT_USER_NAME; static final String HISTORY_LOG_CONFIG_NAME; static final String SPYDRA_HISTORY_CLIENT_ID_PROPERTY; static final String SPYDRA_HISTORY_USERNAME_PROPERTY; static final String SPYDRA_HISTORY_BUCKET_PROPERTY; }
@Test public void testFindHistoryFilePath() throws Exception { final Iterator<LocatedFileStatus> mockListing = Arrays.asList( mockFileStatus("/foobar.jhist"), mockFileStatus("/barbaz.jhist"), mockFileStatus("/a.log"), mockFileStatus("/" + DUMMY_JHIST_NAME)) .iterator(); Optional<String> jHistFile = HistoryLogUtils.findHistoryFilePath(mockListing, ApplicationId.newInstance(DUMMY_ID_TIMESTAMP, DUMMY_ID_SERIAL)); assertTrue(jHistFile.isPresent()); assertEquals("/" + DUMMY_JHIST_NAME, jHistFile.get()); } @Test public void testNoHistoryFound() throws Exception { final Iterator<LocatedFileStatus> mockListing = Arrays.asList(mockFileStatus("/a.log")).iterator(); Optional<String> jHistFile = HistoryLogUtils.findHistoryFilePath(mockListing, ApplicationId.newInstance(DUMMY_ID_TIMESTAMP, DUMMY_ID_SERIAL)); assertFalse(jHistFile.isPresent()); }
OnPremiseExecutor implements Executor { @VisibleForTesting List<String> getCommand(SpydraArgument arguments) { addBaseCommand(); if (arguments.getSubmit().getOptions().containsKey(OPTION_JAR)) { addArgument(arguments.getSubmit().getOptions().get(OPTION_JAR)); } if (arguments.getSubmit().getOptions().containsKey(OPTION_CLASS)) { addArgument(arguments.getSubmit().getOptions().get(OPTION_CLASS)); } arguments.getSubmit().jobArgs.ifPresent(this::addArguments); if (arguments.getSubmit().getOptions().containsKey(OPTION_PROPERTIES)) { addProperties(arguments.getSubmit().getOptions().get(OPTION_PROPERTIES)); } return this.command; } OnPremiseExecutor(); @VisibleForTesting OnPremiseExecutor(Metrics metrics); @Override boolean submit(SpydraArgument arguments); }
@Test public void testGetCommand() { String jarPath = "jarPath"; List<String> args = new ArrayList<>(); args.add("arg1"); String mainClass = "mainClass"; String[] properties = new String[]{ "propertyName0=propertyValue0", "propertyName1=propertyValue1"}; SpydraArgument arguments = new SpydraArgument(); arguments.getSubmit().getOptions().put(OPTION_JAR, jarPath); arguments.getSubmit().getOptions().put(OPTION_CLASS, mainClass); arguments.getSubmit().getOptions().put(SpydraArgument.OPTION_PROPERTIES, String.join(",", properties)); arguments.getSubmit().setJobArgs(args); OnPremiseExecutor executor = new OnPremiseExecutor(); List<String> command = executor.getCommand(arguments); String[] baseCommand = OnPremiseExecutor.BASE_COMMAND.split(" "); for (int i = 0; i < baseCommand.length; i++) { assertEquals(baseCommand[i], command.get(i)); } assertEquals(command.get(baseCommand.length), jarPath); assertEquals(command.get(baseCommand.length + 1), mainClass); int count = 0; for (int i = 0; i < command.size() - 1; i++) { if (command.get(i).equals(OnPremiseExecutor.PROPERTY)) { assertTrue(command.contains(properties[0]) || command.contains(properties[1])); count++; } } assertEquals(properties.length, count); String expectedCommand = "hadoop jar jarPath mainClass arg1 " + "-D propertyName0=propertyValue0 " + "-D propertyName1=propertyValue1"; String actualCommand = String.join(" ", command); assertEquals(expectedCommand, actualCommand); }
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); }
@Test public void testFrom() { ClusterPlacement clusterPlacement = ClusterPlacement.from("10-15"); assertThat(clusterPlacement.clusterNumber(), is(10)); assertThat(clusterPlacement.clusterGeneration(), is(15L)); }
ClusterPlacement { String token() { return String.format("%s-%s", clusterNumber(), clusterGeneration()); } Optional<Cluster> findIn(List<Cluster> clusters); }
@Test public void testToken() { final ClusterPlacement clusterPlacement = new ClusterPlacementBuilder().clusterNumber(10).clusterGeneration(15L).build(); assertThat(clusterPlacement.token(), is("10-15")); }
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); }
@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)); }
ClusterPlacement { public Optional<Cluster> findIn(List<Cluster> clusters) { return clusters.stream() .filter(cluster -> this.equals(placement(cluster))) .findFirst(); } Optional<Cluster> findIn(List<Cluster> clusters); }
@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)); }
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; }
@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); }
SubmissionCliParser implements CliParser<SpydraArgument> { public SpydraArgument parse(String[] args) throws IOException { DefaultParser parser = new DefaultParser(); CommandLine cmdLine; cmdLine = CliHelper.tryParse(parser, options, args); SpydraArgument spydraArgument = new SpydraArgument(); if (cmdLine.hasOption(CliConsts.SPYDRA_JSON_OPTION_NAME)) { String[] files = cmdLine.getOptionValues(CliConsts.SPYDRA_JSON_OPTION_NAME); for (String file : files) { spydraArgument = SpydraArgument.merge( spydraArgument, JsonHelper.objectMapper().readValue(new File(file), SpydraArgument.class)); } } if (cmdLine.hasOption(CliConsts.JAR_OPTION_NAME)) { spydraArgument.getSubmit().getOptions().put( SpydraArgument.OPTION_JAR, cmdLine.getOptionValue(CliConsts.JAR_OPTION_NAME)); } if (cmdLine.hasOption(CliConsts.CLIENT_ID_OPTION_NAME)) { spydraArgument.setClientId(cmdLine.getOptionValue(CliConsts.CLIENT_ID_OPTION_NAME)); } if (cmdLine.hasOption(CliConsts.JARS_OPTION_NAME)) { spydraArgument.getSubmit().getOptions().put( SpydraArgument.OPTION_JARS, String.join(",", cmdLine.getOptionValues(CliConsts.JARS_OPTION_NAME))); } if (cmdLine.hasOption(CliConsts.JOBNAME_OPTION_NAME)) { spydraArgument.getSubmit().getOptions().put( SpydraArgument.OPTION_JOB_ID, sanitizeJobId(cmdLine.getOptionValue(CliConsts.JOBNAME_OPTION_NAME))); } if (spydraArgument.jobType.isPresent()) { spydraArgument.setJobType(spydraArgument.getJobType().toLowerCase()); } if (cmdLine.hasOption(SpydraArgument.OPTION_DRYRUN)) { spydraArgument.setDryRun(true); } List<String> jobArgs = new LinkedList<>(cmdLine.getArgList()); if (jobArgs.size() > 0) { spydraArgument.getSubmit().setJobArgs(jobArgs); } return spydraArgument; } SubmissionCliParser(); SpydraArgument parse(String[] args); @Override boolean enoughArgs(String[] args); void printHelp(); }
@Test public void testMultipleSpydraJson() throws IOException { File jsonFile1 = temporaryFolder.newFile("spydra1.json"); File jsonFile2 = temporaryFolder.newFile("spydra2.json"); JsonHelper.objectMapper().writeValue(jsonFile1, new HashMap<String, Map<String, Map<String, String>>>() {{ put("cluster", singletonMap("options", singletonMap("labels", "ck1=cv1"))); put("submit", singletonMap("options", singletonMap("labels", "sk1=sv1"))); }}); JsonHelper.objectMapper().writeValue(jsonFile2, new HashMap<String, Map<String, Map<String, String>>>() {{ put("cluster", singletonMap("options", singletonMap("labels", "ck2=cv2"))); put("submit", singletonMap("options", singletonMap("labels", "sk2=sv2"))); }}); SubmissionCliParser parser = new SubmissionCliParser(); String[] args = { "--spydra-json", jsonFile1.toString(), "--spydra-json", jsonFile2.toString(), }; SpydraArgument argument = parser.parse(args); assertEquals("ck1=cv1,ck2=cv2", argument.cluster.options.get("labels")); assertEquals("sk1=sv1,sk2=sv2", argument.submit.options.get("labels")); }
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); }
@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); }
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); }
@Test public void whenDeleteSuccess() throws Exception { mockMvc.perform(delete("/book/1").contentType(MediaType.APPLICATION_JSON)) .andExpect(status().isOk()); }
Packer implements Writable, MessageFormatter { @Override public void writeBinary(byte[] binary, int offset, int length) { writeBinaryHeader(length); buffer.put(binary, offset, length); } 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); }
@Test public void testWriteBinary() { final byte[] data = new byte[] {1, 2, 3, 4}; MessageFormatter messageFormatter = new Packer( new ByteBufferConsumer() { @Override public void accept(int messageCount, ByteBuffer buffy) { MessageUnpacker unpacker = MessagePack.newDefaultUnpacker(buffy); try { assertEquals(1, unpacker.unpackArrayHeader()); int length = unpacker.unpackBinaryHeader(); assertEquals(4, length); assertArrayEquals(data, unpacker.readPayload(length)); } catch (IOException e) { Assert.fail(e.getMessage()); } } }, ByteBuffer.allocate(25)); messageFormatter.format( data, new Mapper<byte[]>() { @Override public void map(byte[] data, Writable writable) { writable.writeBinary(data, 0, data.length); } }); messageFormatter.flush(); }
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(); }
@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(); }
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(); }
@Test public void testClose() { ongoingRecording.close(); verify(recording).close(); }
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); }
@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(); }
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(); }
@Test public void testGetStream() throws IOException { assertEquals(stream, recordingData.getStream()); } @Test public void testCustomGetStream() throws IOException { assertEquals(customStream, customRecordingData.getStream()); }
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(); }
@Test public void testRelease() { recordingData.release(); verify(recording).close(); }
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(); }
@Test public void testGetName() { assertEquals(TEST_NAME, recordingData.getName()); }
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(); }
@Test public void testToString() { assertThat(recordingData.toString(), containsString(TEST_NAME)); }
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(); }
@Test public void testGetStart() { assertEquals(start, recordingData.getStart()); } @Test public void testCustomGetStart() { assertEquals(customStart, customRecordingData.getStart()); }
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(); }
@Test public void testGetEnd() { assertEquals(end, recordingData.getEnd()); } @Test public void testCustomGetEnd() { assertEquals(customEnd, customRecordingData.getEnd()); }
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); }
@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(); }
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(); }
@Test public void getRecording() { assertEquals(recording, recordingData.getRecording()); }
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(); }
@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()); }
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); }
@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)); }
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); }
@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); }
StreamUtils { public static <T> T gzipStream( InputStream is, final int expectedSize, final BytesConsumer<T> consumer) throws IOException { is = ensureMarkSupported(is); if (isCompressed(is)) { return readStream(is, expectedSize, consumer); } else { final FastByteArrayOutputStream baos = new FastByteArrayOutputStream(expectedSize); try (final OutputStream zipped = new GZIPOutputStream(baos)) { copy(is, zipped); } return baos.consume(consumer); } } 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); }
@Test public void gzipStream() throws IOException { final int expectedSize = 1; final byte[] gzippedBytes = StreamUtils.gzipStream(testRecordingStream(), expectedSize, CONSUME_TO_BYTES); assertArrayEquals(testRecordingBytes, uncompressGzip(gzippedBytes)); } @Test public void gzipStreamLargeExpectedSize() throws IOException { final int expectedSize = testRecordingBytes.length * 2; final byte[] gzippedBytes = StreamUtils.gzipStream(testRecordingStream(), expectedSize, CONSUME_TO_BYTES); assertArrayEquals(testRecordingBytes, uncompressGzip(gzippedBytes)); } @Test public void gzipAlreadyGzippedStream() throws IOException { final byte[] bytes = StreamUtils.gzipStream( new ByteArrayInputStream(testRecordingGzippedBytes), DEFAULT_EXPECTED_SIZE, CONSUME_TO_BYTES); assertArrayEquals(testRecordingGzippedBytes, bytes); } @Test public void gzipAlreadyZippedStream() throws IOException { final byte[] bytes = StreamUtils.gzipStream( new ByteArrayInputStream(testRecordingZippedBytes), DEFAULT_EXPECTED_SIZE, CONSUME_TO_BYTES); assertArrayEquals(testRecordingZippedBytes, bytes); } @Test public void gzipAlreadyLz4edStream() throws IOException { final byte[] bytes = StreamUtils.gzipStream( new ByteArrayInputStream(testRecordingLz4edBytes), DEFAULT_EXPECTED_SIZE, CONSUME_TO_BYTES); assertArrayEquals(testRecordingLz4edBytes, bytes); }
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); }
@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(); }
StreamUtils { public static <T> T lz4Stream( InputStream is, final int expectedSize, final BytesConsumer<T> consumer) throws IOException { is = ensureMarkSupported(is); if (isCompressed(is)) { return readStream(is, expectedSize, consumer); } else { final FastByteArrayOutputStream baos = new FastByteArrayOutputStream(expectedSize); try (final OutputStream zipped = new LZ4FrameOutputStream( baos, LZ4FrameOutputStream.BLOCKSIZE.SIZE_64KB, LZ4FrameOutputStream.FLG.Bits.BLOCK_INDEPENDENCE)) { copy(is, zipped); } return baos.consume(consumer); } } 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); }
@Test public void lz4Stream() throws IOException { final int expectedSize = 1; final byte[] gzippedBytes = StreamUtils.lz4Stream(testRecordingStream(), expectedSize, CONSUME_TO_BYTES); assertArrayEquals(testRecordingBytes, uncompressLz4(gzippedBytes)); } @Test public void lz4StreamLargeExpectedSize() throws IOException { final int expectedSize = testRecordingBytes.length * 2; final byte[] gzippedBytes = StreamUtils.lz4Stream(testRecordingStream(), expectedSize, CONSUME_TO_BYTES); assertArrayEquals(testRecordingBytes, uncompressLz4(gzippedBytes)); } @Test public void lz4AlreadyGzippedStream() throws IOException { final byte[] bytes = StreamUtils.lz4Stream( new ByteArrayInputStream(testRecordingGzippedBytes), DEFAULT_EXPECTED_SIZE, CONSUME_TO_BYTES); assertArrayEquals(testRecordingGzippedBytes, bytes); } @Test public void lz4AlreadyZippedStream() throws IOException { final byte[] bytes = StreamUtils.lz4Stream( new ByteArrayInputStream(testRecordingZippedBytes), DEFAULT_EXPECTED_SIZE, CONSUME_TO_BYTES); assertArrayEquals(testRecordingZippedBytes, bytes); } @Test public void lz4AlreadyLz4edStream() throws IOException { final byte[] bytes = StreamUtils.lz4Stream( new ByteArrayInputStream(testRecordingLz4edBytes), DEFAULT_EXPECTED_SIZE, CONSUME_TO_BYTES); assertArrayEquals(testRecordingLz4edBytes, bytes); }
ProfileUploader { public void upload(final RecordingType type, final RecordingData data) { try { if (canEnqueueMoreRequests()) { makeUploadRequest(type, data); } else { log.warn("Cannot upload profile data: too many enqueued requests!"); } } catch (final IllegalStateException | IOException e) { log.warn("Problem uploading profile!", e); } finally { try { data.getStream().close(); } catch (final IllegalStateException | IOException e) { log.warn("Problem closing profile stream", e); } data.release(); } } ProfileUploader(final Config config); ProfileUploader( final Config config, final RatelimitedLogger ratelimitedLogger, final String containerId); void upload(final RecordingType type, final RecordingData data); void shutdown(); }
@Test public void testRequestWithContainerId() throws IOException, InterruptedException { uploader = new ProfileUploader(config, ratelimitedLogger, "container-id"); server.enqueue(new MockResponse().setResponseCode(200)); uploader.upload(RECORDING_TYPE, mockRecordingData(RECORDING_RESOURCE)); final RecordedRequest request = server.takeRequest(5, TimeUnit.SECONDS); assertNotNull(request); assertEquals(request.getHeader(ProfileUploader.HEADER_DD_CONTAINER_ID), "container-id"); } @Test public void testRequestWithNoAPIKey() throws IOException, InterruptedException { when(config.getApiKey()).thenReturn(null); uploader = new ProfileUploader(config); server.enqueue(new MockResponse().setResponseCode(200)); uploader.upload(RECORDING_TYPE, mockRecordingData(RECORDING_RESOURCE)); final RecordedRequest request = server.takeRequest(5, TimeUnit.SECONDS); assertNotNull(request); assertNull(request.getHeader(ProfileUploader.HEADER_DD_API_KEY)); } @Test public void test404WithoutAPIKey() throws IOException, InterruptedException { when(config.getApiKey()).thenReturn(null); uploader = new ProfileUploader(config); server.enqueue(new MockResponse().setResponseCode(404)); uploader.upload(RECORDING_TYPE, mockRecordingData(RECORDING_RESOURCE)); final RecordedRequest request = server.takeRequest(5, TimeUnit.SECONDS); assertNotNull(request); assertNull(request.getHeader(ProfileUploader.HEADER_DD_API_KEY)); } @Test public void test404WithAPIKey() throws IOException, InterruptedException { when(config.getApiKey()).thenReturn(API_KEY_VALUE); uploader = new ProfileUploader(config); server.enqueue(new MockResponse().setResponseCode(404)); uploader.upload(RECORDING_TYPE, mockRecordingData(RECORDING_RESOURCE)); final RecordedRequest request = server.takeRequest(5, TimeUnit.SECONDS); assertNotNull(request); assertEquals(request.getHeader(ProfileUploader.HEADER_DD_API_KEY), API_KEY_VALUE); } @Test public void testRequestWithProxy() throws IOException, InterruptedException { final String backendHost = "intake.profiling.datadoghq.com:1234"; final String backendUrl = "http: when(config.getFinalProfilingUrl()) .thenReturn("http: when(config.getProfilingProxyHost()).thenReturn(server.url("").host()); when(config.getProfilingProxyPort()).thenReturn(server.url("").port()); when(config.getProfilingProxyUsername()).thenReturn("username"); when(config.getProfilingProxyPassword()).thenReturn("password"); uploader = new ProfileUploader(config); server.enqueue(new MockResponse().setResponseCode(407).addHeader("Proxy-Authenticate: Basic")); server.enqueue(new MockResponse().setResponseCode(200)); uploader.upload(RECORDING_TYPE, mockRecordingData(RECORDING_RESOURCE)); final RecordedRequest recordedFirstRequest = server.takeRequest(5, TimeUnit.SECONDS); assertEquals(server.url(""), recordedFirstRequest.getRequestUrl()); assertEquals(API_KEY_VALUE, recordedFirstRequest.getHeader(ProfileUploader.HEADER_DD_API_KEY)); assertNull(recordedFirstRequest.getHeader("Proxy-Authorization")); assertEquals(backendHost, recordedFirstRequest.getHeader("Host")); assertEquals( String.format("POST %s HTTP/1.1", backendUrl), recordedFirstRequest.getRequestLine()); final RecordedRequest recordedSecondRequest = server.takeRequest(5, TimeUnit.SECONDS); assertEquals(server.url(""), recordedSecondRequest.getRequestUrl()); assertEquals(API_KEY_VALUE, recordedSecondRequest.getHeader(ProfileUploader.HEADER_DD_API_KEY)); assertEquals( Credentials.basic("username", "password"), recordedSecondRequest.getHeader("Proxy-Authorization")); assertEquals(backendHost, recordedSecondRequest.getHeader("Host")); assertEquals( String.format("POST %s HTTP/1.1", backendUrl), recordedSecondRequest.getRequestLine()); } @Test public void testRequestWithProxyDefaultPassword() throws IOException, InterruptedException { final String backendUrl = "http: when(config.getFinalProfilingUrl()) .thenReturn("http: when(config.getProfilingProxyHost()).thenReturn(server.url("").host()); when(config.getProfilingProxyPort()).thenReturn(server.url("").port()); when(config.getProfilingProxyUsername()).thenReturn("username"); uploader = new ProfileUploader(config); server.enqueue(new MockResponse().setResponseCode(407).addHeader("Proxy-Authenticate: Basic")); server.enqueue(new MockResponse().setResponseCode(200)); uploader.upload(RECORDING_TYPE, mockRecordingData(RECORDING_RESOURCE)); final RecordedRequest recordedFirstRequest = server.takeRequest(5, TimeUnit.SECONDS); final RecordedRequest recordedSecondRequest = server.takeRequest(5, TimeUnit.SECONDS); assertEquals( Credentials.basic("username", ""), recordedSecondRequest.getHeader("Proxy-Authorization")); } @Test public void testRecordingClosed() throws IOException { server.enqueue(new MockResponse().setResponseCode(200)); final RecordingData recording = mockRecordingData(RECORDING_RESOURCE); uploader.upload(RECORDING_TYPE, recording); verify(recording.getStream()).close(); verify(recording).release(); } @Test public void test500Response() throws IOException, InterruptedException { server.enqueue(new MockResponse().setResponseCode(500)); final RecordingData recording = mockRecordingData(RECORDING_RESOURCE); uploader.upload(RECORDING_TYPE, recording); assertNotNull(server.takeRequest(5, TimeUnit.SECONDS)); verify(recording.getStream()).close(); verify(recording).release(); } @Test public void testTimeout() throws IOException, InterruptedException { server.enqueue( new MockResponse() .setHeadersDelay( REQUEST_IO_OPERATION_TIMEOUT.plus(Duration.ofMillis(1000)).toMillis(), TimeUnit.MILLISECONDS)); final RecordingData recording = mockRecordingData(RECORDING_RESOURCE); uploader.upload(RECORDING_TYPE, recording); assertNotNull(server.takeRequest(5, TimeUnit.SECONDS)); verify(recording.getStream()).close(); verify(recording).release(); } @Test public void testUnfinishedRecording() throws IOException { final RecordingData recording = mockRecordingData(RECORDING_RESOURCE); when(recording.getStream()).thenThrow(new IllegalStateException("test exception")); uploader.upload(RECORDING_TYPE, recording); verify(recording).release(); verify(recording, times(2)).getStream(); verifyNoMoreInteractions(recording); } @Test public void testHeaders() throws IOException, InterruptedException { server.enqueue(new MockResponse().setResponseCode(200)); uploader.upload(RECORDING_TYPE, mockRecordingData(RECORDING_RESOURCE)); final RecordedRequest recordedRequest = server.takeRequest(5, TimeUnit.SECONDS); assertEquals( ProfileUploader.JAVA_LANG, recordedRequest.getHeader(ProfileUploader.DATADOG_META_LANG)); } @Test public void testEnqueuedRequestsExecuted() throws IOException, InterruptedException { for (int i = 0; i < ProfileUploader.MAX_RUNNING_REQUESTS; i++) { server.enqueue( new MockResponse() .setHeadersDelay( Duration.ofMillis(1000).toMillis(), TimeUnit.MILLISECONDS) .setResponseCode(200)); } server.enqueue(new MockResponse().setResponseCode(200)); for (int i = 0; i < ProfileUploader.MAX_RUNNING_REQUESTS; i++) { final RecordingData recording = mockRecordingData(RECORDING_RESOURCE); uploader.upload(RECORDING_TYPE, recording); } final RecordingData additionalRecording = mockRecordingData(RECORDING_RESOURCE); uploader.upload(RECORDING_TYPE, additionalRecording); for (int i = 0; i < ProfileUploader.MAX_RUNNING_REQUESTS; i++) { assertNotNull(server.takeRequest(5, TimeUnit.SECONDS)); } assertNotNull(server.takeRequest(2000, TimeUnit.MILLISECONDS), "Got enqueued request"); verify(additionalRecording.getStream()).close(); verify(additionalRecording).release(); } @Test public void testTooManyRequests() throws IOException, InterruptedException { when(config.getProfilingUploadTimeout()).thenReturn((int) FOREVER_REQUEST_TIMEOUT.getSeconds()); uploader = new ProfileUploader(config); for (int i = 0; i < ProfileUploader.MAX_RUNNING_REQUESTS; i++) { server.enqueue( new MockResponse() .setHeadersDelay(FOREVER_REQUEST_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS) .setResponseCode(200)); } server.enqueue(new MockResponse().setResponseCode(200)); for (int i = 0; i < ProfileUploader.MAX_RUNNING_REQUESTS; i++) { final RecordingData recording = mockRecordingData(RECORDING_RESOURCE); uploader.upload(RECORDING_TYPE, recording); } final List<RecordingData> hangingRequests = new ArrayList<>(); for (int i = 0; i < ProfileUploader.MAX_ENQUEUED_REQUESTS + 1; i++) { final RecordingData recording = mockRecordingData(RECORDING_RESOURCE); hangingRequests.add(recording); uploader.upload(RECORDING_TYPE, recording); } for (int i = 0; i < ProfileUploader.MAX_RUNNING_REQUESTS; i++) { assertNotNull(server.takeRequest(5, TimeUnit.SECONDS)); } assertNull(server.takeRequest(100, TimeUnit.MILLISECONDS), "No more requests"); for (final RecordingData recording : hangingRequests) { verify(recording.getStream()).close(); verify(recording).release(); } }
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(); }
@Test void getByIndexEmpty() { assertNull(instance.get(-1)); assertNull(instance.get(0)); }
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(); }
@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)); }
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(); }
@Test void insertInvalid() { assertThrows(IllegalArgumentException.class, () -> instance.insert(1, null)); } @Test void insertNull() { assertDoesNotThrow(() -> instance.insert(-1, null)); }
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(); }
@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(); }
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); }
@Test public void testThreadName() { final Thread thread = factory.newThread(() -> {}); assertEquals("test-name", thread.getName()); }
ControllerFactory { public static Controller createController(final Config config) throws UnsupportedEnvironmentException, ConfigurationException { try { Class.forName("com.oracle.jrockit.jfr.Producer"); throw new UnsupportedEnvironmentException( "Not enabling profiling; it requires Oracle Java 11+."); } catch (final ClassNotFoundException e) { } try { final Class<? extends Controller> clazz = Class.forName("com.datadog.profiling.controller.openjdk.OpenJdkController") .asSubclass(Controller.class); return clazz.getDeclaredConstructor(Config.class).newInstance(config); } catch (final ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) { if (e.getCause() != null && e.getCause() instanceof ConfigurationException) { throw (ConfigurationException) e.getCause(); } final String message = "Not enabling profiling" + getFixProposalMessage(); throw new UnsupportedEnvironmentException(message, e); } } static Controller createController(final Config config); }
@Test @EnabledOnJre({JAVA_8}) public void testCreateControllerJava8() { final UnsupportedEnvironmentException unsupportedEnvironmentException = assertThrows( UnsupportedEnvironmentException.class, () -> { ControllerFactory.createController(config); }); String expected = "Not enabling profiling; it requires OpenJDK 11+, Oracle Java 11+, or Zulu Java 8 (1.8.0_212+)."; final String javaVendor = System.getProperty("java.vendor"); final String javaRuntimeName = System.getProperty("java.runtime.name"); final String javaVersion = System.getProperty("java.version"); if ("Azul Systems, Inc.".equals(javaVendor)) { expected = "Not enabling profiling; it requires Zulu Java 8 (1.8.0_212+)."; } else if ("Java(TM) SE Runtime Environment".equals(javaRuntimeName) && "Oracle Corporation".equals(javaVendor) && javaVersion.startsWith("1.8")) { expected = "Not enabling profiling; it requires Oracle Java 11+."; } else if ("OpenJDK Runtime Environment".equals(javaRuntimeName)) { expected = "Not enabling profiling; it requires 1.8.0_262+ OpenJDK builds from the following vendors: AdoptOpenJDK, Amazon Corretto, Azul Zulu, BellSoft Liberica"; } assertEquals( expected, unsupportedEnvironmentException.getMessage(), "'" + javaRuntimeName + "' / '" + javaVendor + "' / '" + javaVersion + "'"); }
ProfilingSystem { public final void shutdown() { executorService.shutdownNow(); try { executorService.awaitTermination(TERMINATION_TIMEOUT, TimeUnit.SECONDS); } catch (final InterruptedException e) { log.error("Wait for executor shutdown interrupted"); } if (recording != null) { recording.close(); } started = false; } 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; }
@Test public void testShutdown() throws ConfigurationException { final ProfilingSystem system = new ProfilingSystem( controller, listener, Duration.ofMillis(10), Duration.ZERO, Duration.ofMillis(300), false, pool, threadLocalRandom); startProfilingSystem(system); verify(controller).createRecording(any()); system.shutdown(); verify(recording).close(); assertTrue(pool.isTerminated()); } @Test public void testShutdownWithRunningProfilingRecording() throws ConfigurationException { final ProfilingSystem system = new ProfilingSystem( controller, listener, Duration.ofMillis(10), Duration.ZERO, Duration.ofMillis(300), false, pool, threadLocalRandom); startProfilingSystem(system); verify(controller).createRecording(any()); system.shutdown(); verify(recording).close(); assertTrue(pool.isTerminated()); } @Test public void testShutdownInterruption() throws ConfigurationException { final Thread mainThread = Thread.currentThread(); doAnswer( (InvocationOnMock invocation) -> { while (!pool.isShutdown()) { try { Thread.sleep(100); } catch (final InterruptedException e) { } } mainThread.interrupt(); return null; }) .when(listener) .onNewData(any(), any()); final ProfilingSystem system = new ProfilingSystem( controller, listener, Duration.ofMillis(10), Duration.ofMillis(5), Duration.ofMillis(100), false, pool, threadLocalRandom); startProfilingSystem(system); verify(controller, timeout(300)).createRecording(any()); system.shutdown(); assertTrue(true, "Shutdown exited cleanly after interruption"); } @Test public void testCanShutDownWithoutStarting() throws ConfigurationException { final ProfilingSystem system = new ProfilingSystem( controller, listener, Duration.ofMillis(10), Duration.ofMillis(5), Duration.ofMillis(300), false, pool, threadLocalRandom); system.shutdown(); assertTrue(pool.isTerminated()); } @Test public void testDoesntSendDataIfNotStarted() throws InterruptedException, ConfigurationException { final ProfilingSystem system = new ProfilingSystem( controller, listener, Duration.ofMillis(10), Duration.ofMillis(5), Duration.ofMillis(1), false); Thread.sleep(50); system.shutdown(); verify(controller, never()).createRecording(any()); verify(listener, never()).onNewData(any(), any()); } @Test public void testDoesntSendPeriodicRecordingIfPeriodicRecordingIsDisabled() throws InterruptedException, ConfigurationException { when(recording.snapshot(any(), any())).thenReturn(recordingData); final ProfilingSystem system = new ProfilingSystem( controller, listener, Duration.ofMillis(10), Duration.ofMillis(5), Duration.ofMillis(10), false); startProfilingSystem(system); Thread.sleep(200); system.shutdown(); verify(listener, atLeastOnce()).onNewData(CONTINUOUS, recordingData); } @Test public void testRecordingSnapshotError() throws ConfigurationException { final Duration uploadPeriod = Duration.ofMillis(300); final List<RecordingData> generatedRecordingData = new ArrayList<>(); when(recording.snapshot(any(), any())) .thenThrow(new RuntimeException("Test")) .thenAnswer(generateMockRecordingData(generatedRecordingData)); final ProfilingSystem system = new ProfilingSystem( controller, listener, Duration.ofMillis(10), Duration.ofMillis(5), uploadPeriod, false, pool, threadLocalRandom); startProfilingSystem(system); final ArgumentCaptor<RecordingData> captor = ArgumentCaptor.forClass(RecordingData.class); verify(listener, timeout(REASONABLE_TIMEOUT).atLeast(2)) .onNewData(eq(CONTINUOUS), captor.capture()); assertEquals(generatedRecordingData, captor.getAllValues()); system.shutdown(); } @Test public void testRecordingSnapshotNoData() throws ConfigurationException { final Duration uploadPeriod = Duration.ofMillis(300); final List<RecordingData> generatedRecordingData = new ArrayList<>(); when(recording.snapshot(any(), any())) .thenReturn(null) .thenAnswer(generateMockRecordingData(generatedRecordingData)); final ProfilingSystem system = new ProfilingSystem( controller, listener, Duration.ofMillis(10), Duration.ofMillis(5), uploadPeriod, false, pool, threadLocalRandom); startProfilingSystem(system); final ArgumentCaptor<RecordingData> captor = ArgumentCaptor.forClass(RecordingData.class); verify(listener, timeout(REASONABLE_TIMEOUT).times(2)) .onNewData(eq(CONTINUOUS), captor.capture()); assertEquals(generatedRecordingData, captor.getAllValues()); system.shutdown(); }
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; }
@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()); }
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(); }
@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()); }
AbstractLEB128Writer implements LEB128Writer { static int getPackedIntLen(long data) { if ((data & COMPRESSED_INT_MASK) == 0) { return 1; } data >>= 7; if ((data & COMPRESSED_INT_MASK) == 0) { return 2; } data >>= 7; if ((data & COMPRESSED_INT_MASK) == 0) { return 3; } data >>= 7; if ((data & COMPRESSED_INT_MASK) == 0) { return 4; } data >>= 7; if ((data & COMPRESSED_INT_MASK) == 0) { return 5; } data >>= 7; if ((data & COMPRESSED_INT_MASK) == 0) { return 6; } data >>= 7; if ((data & COMPRESSED_INT_MASK) == 0) { return 7; } data >>= 7; if ((data & COMPRESSED_INT_MASK) == 0) { return 8; } return 9; } @Override final LEB128Writer writeChar(char data); @Override final int writeChar(int offset, char data); @Override final LEB128Writer writeShort(short data); @Override final int writeShort(int offset, short data); @Override final LEB128Writer writeInt(int data); @Override final int writeInt(int offset, int data); @Override final LEB128Writer writeLong(long data); @Override final int writeLong(int offset, long data); @Override final LEB128Writer writeFloat(float data); @Override final LEB128Writer writeDouble(double data); @Override final LEB128Writer writeBoolean(boolean data); @Override final int writeBoolean(int offset, boolean data); @Override final LEB128Writer writeByte(byte data); @Override final LEB128Writer writeBytes(byte... data); @Override final LEB128Writer writeUTF(String data); @Override final LEB128Writer writeUTF(byte[] data); @Override final int writeUTF(int offset, String data); @Override final int writeUTF(int offset, byte[] data); @Override final LEB128Writer writeCompactUTF(byte[] data); @Override final LEB128Writer writeCompactUTF(String data); @Override final int writeCompactUTF(int offset, byte[] data); @Override final int writeCompactUTF(int offset, String data); @Override final LEB128Writer writeShortRaw(short data); @Override final LEB128Writer writeIntRaw(int data); @Override final LEB128Writer writeLongRaw(long data); @Override final int length(); }
@Test void testGetPackedIntLen() { assertEquals(1, AbstractLEB128Writer.getPackedIntLen(0)); long val = 1L; for (int i = 1; i < 10; i++) { assertEquals(Math.max(i - 1, 1), AbstractLEB128Writer.getPackedIntLen(val - 1)); assertEquals(i, AbstractLEB128Writer.getPackedIntLen(val)); val = val << 7; } }
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(); }
@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(); }
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); }
@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); }
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); }
@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."); } }
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); }
@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."); } }
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); }
@Test public void failureExceptionIsNotNull() { try { behavior.setFailureException(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("exception == null"); } }
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); }
@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."); } }
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); }
@Test public void errorFactoryIsNotNull() { try { behavior.setErrorFactory(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("errorFactory == null"); } }
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); }
@Test public void retrofitPropagated() { MockRetrofit mockRetrofit = new MockRetrofit.Builder(retrofit).build(); assertThat(mockRetrofit.retrofit()).isSameAs(retrofit); }
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); }
@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); }
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); }
@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); }
RxJava3CallAdapterFactory extends CallAdapter.Factory { @Override public @Nullable CallAdapter<?, ?> get( Type returnType, Annotation[] annotations, Retrofit retrofit) { Class<?> rawType = getRawType(returnType); if (rawType == Completable.class) { return new RxJava3CallAdapter( Void.class, scheduler, isAsync, false, true, false, false, false, true); } boolean isFlowable = rawType == Flowable.class; boolean isSingle = rawType == Single.class; boolean isMaybe = rawType == Maybe.class; if (rawType != Observable.class && !isFlowable && !isSingle && !isMaybe) { return null; } boolean isResult = false; boolean isBody = false; Type responseType; if (!(returnType instanceof ParameterizedType)) { String name = isFlowable ? "Flowable" : isSingle ? "Single" : isMaybe ? "Maybe" : "Observable"; throw new IllegalStateException( name + " return type must be parameterized" + " as " + name + "<Foo> or " + name + "<? extends Foo>"); } Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType); Class<?> rawObservableType = getRawType(observableType); if (rawObservableType == Response.class) { if (!(observableType instanceof ParameterizedType)) { throw new IllegalStateException( "Response must be parameterized" + " as Response<Foo> or Response<? extends Foo>"); } responseType = getParameterUpperBound(0, (ParameterizedType) observableType); } else if (rawObservableType == Result.class) { if (!(observableType instanceof ParameterizedType)) { throw new IllegalStateException( "Result must be parameterized" + " as Result<Foo> or Result<? extends Foo>"); } responseType = getParameterUpperBound(0, (ParameterizedType) observableType); isResult = true; } else { responseType = observableType; isBody = true; } return new RxJava3CallAdapter( responseType, scheduler, isAsync, isResult, isBody, isFlowable, isSingle, isMaybe, 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); }
@Test public void rawResultTypeThrows() { Type observableType = new TypeToken<Observable<Result>>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Result must be parameterized as Result<Foo> or Result<? extends Foo>"); } Type singleType = new TypeToken<Single<Result>>() {}.getType(); try { factory.get(singleType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Result must be parameterized as Result<Foo> or Result<? extends Foo>"); } Type maybeType = new TypeToken<Maybe<Result>>() {}.getType(); try { factory.get(maybeType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Result must be parameterized as Result<Foo> or Result<? extends Foo>"); } Type flowableType = new TypeToken<Flowable<Result>>() {}.getType(); try { factory.get(flowableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Result must be parameterized as Result<Foo> or Result<? extends Foo>"); } } @Test public void nonRxJavaTypeReturnsNull() { CallAdapter<?, ?> adapter = factory.get(String.class, NO_ANNOTATIONS, retrofit); assertThat(adapter).isNull(); } @Test public void responseTypes() { Type oBodyClass = new TypeToken<Observable<String>>() {}.getType(); assertThat(factory.get(oBodyClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sBodyClass = new TypeToken<Single<String>>() {}.getType(); assertThat(factory.get(sBodyClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type mBodyClass = new TypeToken<Maybe<String>>() {}.getType(); assertThat(factory.get(mBodyClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type fBodyClass = new TypeToken<Flowable<String>>() {}.getType(); assertThat(factory.get(fBodyClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oBodyWildcard = new TypeToken<Observable<? extends String>>() {}.getType(); assertThat(factory.get(oBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sBodyWildcard = new TypeToken<Single<? extends String>>() {}.getType(); assertThat(factory.get(sBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type mBodyWildcard = new TypeToken<Maybe<? extends String>>() {}.getType(); assertThat(factory.get(mBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type fBodyWildcard = new TypeToken<Flowable<? extends String>>() {}.getType(); assertThat(factory.get(fBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oBodyGeneric = new TypeToken<Observable<List<String>>>() {}.getType(); assertThat(factory.get(oBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(new TypeToken<List<String>>() {}.getType()); Type sBodyGeneric = new TypeToken<Single<List<String>>>() {}.getType(); assertThat(factory.get(sBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(new TypeToken<List<String>>() {}.getType()); Type mBodyGeneric = new TypeToken<Maybe<List<String>>>() {}.getType(); assertThat(factory.get(mBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(new TypeToken<List<String>>() {}.getType()); Type fBodyGeneric = new TypeToken<Flowable<List<String>>>() {}.getType(); assertThat(factory.get(fBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(new TypeToken<List<String>>() {}.getType()); Type oResponseClass = new TypeToken<Observable<Response<String>>>() {}.getType(); assertThat(factory.get(oResponseClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sResponseClass = new TypeToken<Single<Response<String>>>() {}.getType(); assertThat(factory.get(sResponseClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type mResponseClass = new TypeToken<Maybe<Response<String>>>() {}.getType(); assertThat(factory.get(mResponseClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type fResponseClass = new TypeToken<Flowable<Response<String>>>() {}.getType(); assertThat(factory.get(fResponseClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oResponseWildcard = new TypeToken<Observable<Response<? extends String>>>() {}.getType(); assertThat(factory.get(oResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sResponseWildcard = new TypeToken<Single<Response<? extends String>>>() {}.getType(); assertThat(factory.get(sResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type mResponseWildcard = new TypeToken<Maybe<Response<? extends String>>>() {}.getType(); assertThat(factory.get(mResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type fResponseWildcard = new TypeToken<Flowable<Response<? extends String>>>() {}.getType(); assertThat(factory.get(fResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oResultClass = new TypeToken<Observable<Result<String>>>() {}.getType(); assertThat(factory.get(oResultClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sResultClass = new TypeToken<Single<Result<String>>>() {}.getType(); assertThat(factory.get(sResultClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type mResultClass = new TypeToken<Maybe<Result<String>>>() {}.getType(); assertThat(factory.get(mResultClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type fResultClass = new TypeToken<Flowable<Result<String>>>() {}.getType(); assertThat(factory.get(fResultClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oResultWildcard = new TypeToken<Observable<Result<? extends String>>>() {}.getType(); assertThat(factory.get(oResultWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sResultWildcard = new TypeToken<Single<Result<? extends String>>>() {}.getType(); assertThat(factory.get(sResultWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type mResultWildcard = new TypeToken<Maybe<Result<? extends String>>>() {}.getType(); assertThat(factory.get(mResultWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type fResultWildcard = new TypeToken<Flowable<Result<? extends String>>>() {}.getType(); assertThat(factory.get(fResultWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); } @Test public void rawBodyTypeThrows() { Type observableType = new TypeToken<Observable>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage( "Observable return type must be parameterized as Observable<Foo> or Observable<? extends Foo>"); } Type singleType = new TypeToken<Single>() {}.getType(); try { factory.get(singleType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage( "Single return type must be parameterized as Single<Foo> or Single<? extends Foo>"); } Type maybeType = new TypeToken<Maybe>() {}.getType(); try { factory.get(maybeType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage( "Maybe return type must be parameterized as Maybe<Foo> or Maybe<? extends Foo>"); } Type flowableType = new TypeToken<Flowable>() {}.getType(); try { factory.get(flowableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage( "Flowable return type must be parameterized as Flowable<Foo> or Flowable<? extends Foo>"); } } @Test public void rawResponseTypeThrows() { Type observableType = new TypeToken<Observable<Response>>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } Type singleType = new TypeToken<Single<Response>>() {}.getType(); try { factory.get(singleType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } Type maybeType = new TypeToken<Maybe<Response>>() {}.getType(); try { factory.get(maybeType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } Type flowableType = new TypeToken<Flowable<Response>>() {}.getType(); try { factory.get(flowableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } }
Calls { public static <T> Call<T> response(@Nullable T successValue) { return new FakeCall<>(Response.success(successValue), null); } 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); }
@Test public void bodyExecute() throws IOException { Call<String> taco = Calls.response("Taco"); assertEquals("Taco", taco.execute().body()); } @Test public void bodyEnqueue() throws IOException { Call<String> taco = Calls.response("Taco"); final AtomicReference<Response<String>> responseRef = new AtomicReference<>(); taco.enqueue( new Callback<String>() { @Override public void onResponse(Call<String> call, Response<String> response) { responseRef.set(response); } @Override public void onFailure(Call<String> call, Throwable t) { fail(); } }); assertThat(responseRef.get().body()).isEqualTo("Taco"); } @Test public void responseExecute() throws IOException { Response<String> response = Response.success("Taco"); Call<String> taco = Calls.response(response); assertFalse(taco.isExecuted()); assertSame(response, taco.execute()); assertTrue(taco.isExecuted()); try { taco.execute(); fail(); } catch (IllegalStateException e) { assertThat(e).hasMessage("Already executed"); } } @Test public void responseEnqueue() { Response<String> response = Response.success("Taco"); Call<String> taco = Calls.response(response); assertFalse(taco.isExecuted()); final AtomicReference<Response<String>> responseRef = new AtomicReference<>(); taco.enqueue( new Callback<String>() { @Override public void onResponse(Call<String> call, Response<String> response) { responseRef.set(response); } @Override public void onFailure(Call<String> call, Throwable t) { fail(); } }); assertSame(response, responseRef.get()); assertTrue(taco.isExecuted()); try { taco.enqueue( new Callback<String>() { @Override public void onResponse(Call<String> call, Response<String> response) { fail(); } @Override public void onFailure(Call<String> call, Throwable t) { fail(); } }); fail(); } catch (IllegalStateException e) { assertThat(e).hasMessage("Already executed"); } } @Test public void enqueueNullThrows() { Call<String> taco = Calls.response("Taco"); try { taco.enqueue(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("callback == null"); } } @Test public void responseCancelExecute() { Call<String> taco = Calls.response(Response.success("Taco")); assertFalse(taco.isCanceled()); taco.cancel(); assertTrue(taco.isCanceled()); try { taco.execute(); fail(); } catch (IOException e) { assertThat(e).hasMessage("canceled"); } } @Test public void responseCancelEnqueue() throws IOException { Call<String> taco = Calls.response(Response.success("Taco")); assertFalse(taco.isCanceled()); taco.cancel(); assertTrue(taco.isCanceled()); final AtomicReference<Throwable> failureRef = new AtomicReference<>(); taco.enqueue( new Callback<String>() { @Override public void onResponse(Call<String> call, Response<String> response) { fail(); } @Override public void onFailure(Call<String> call, Throwable t) { failureRef.set(t); } }); assertThat(failureRef.get()).isInstanceOf(IOException.class).hasMessage("canceled"); } @Test public void cloneHasOwnState() throws IOException { Call<String> taco = Calls.response("Taco"); assertEquals("Taco", taco.execute().body()); Call<String> anotherTaco = taco.clone(); assertFalse(anotherTaco.isExecuted()); assertEquals("Taco", anotherTaco.execute().body()); assertTrue(anotherTaco.isExecuted()); }
Calls { public static <T> Call<T> failure(IOException failure) { return new FakeCall<>(null, failure); } 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); }
@Test public void failureExecute() { IOException failure = new IOException("Hey"); Call<Object> taco = Calls.failure(failure); assertFalse(taco.isExecuted()); try { taco.execute(); fail(); } catch (IOException e) { assertSame(failure, e); } assertTrue(taco.isExecuted()); } @Test public void failureExecuteCheckedException() { CertificateException failure = new CertificateException("Hey"); Call<Object> taco = Calls.failure(failure); assertFalse(taco.isExecuted()); try { taco.execute(); fail(); } catch (Exception e) { assertSame(failure, e); } assertTrue(taco.isExecuted()); } @Test public void failureEnqueue() { IOException failure = new IOException("Hey"); Call<Object> taco = Calls.failure(failure); assertFalse(taco.isExecuted()); final AtomicReference<Throwable> failureRef = new AtomicReference<>(); taco.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()); assertTrue(taco.isExecuted()); } @Test public void deferredThrowUncheckedExceptionEnqueue() { final RuntimeException failure = new RuntimeException("Hey"); final AtomicReference<Throwable> failureRef = new AtomicReference<>(); Calls.failure(failure) .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()); }
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(); }
@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"); } }
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); }
@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()); }
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(); }
@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"); } }
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); }
@Test public void nullSchedulerThrows() { try { RxJava2CallAdapterFactory.createWithScheduler(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("scheduler == null"); } }
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); }
@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); }
RxJava2CallAdapterFactory extends CallAdapter.Factory { @Override public @Nullable CallAdapter<?, ?> get( Type returnType, Annotation[] annotations, Retrofit retrofit) { Class<?> rawType = getRawType(returnType); if (rawType == Completable.class) { return new RxJava2CallAdapter( Void.class, scheduler, isAsync, false, true, false, false, false, true); } boolean isFlowable = rawType == Flowable.class; boolean isSingle = rawType == Single.class; boolean isMaybe = rawType == Maybe.class; if (rawType != Observable.class && !isFlowable && !isSingle && !isMaybe) { return null; } boolean isResult = false; boolean isBody = false; Type responseType; if (!(returnType instanceof ParameterizedType)) { String name = isFlowable ? "Flowable" : isSingle ? "Single" : isMaybe ? "Maybe" : "Observable"; throw new IllegalStateException( name + " return type must be parameterized" + " as " + name + "<Foo> or " + name + "<? extends Foo>"); } Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType); Class<?> rawObservableType = getRawType(observableType); if (rawObservableType == Response.class) { if (!(observableType instanceof ParameterizedType)) { throw new IllegalStateException( "Response must be parameterized" + " as Response<Foo> or Response<? extends Foo>"); } responseType = getParameterUpperBound(0, (ParameterizedType) observableType); } else if (rawObservableType == Result.class) { if (!(observableType instanceof ParameterizedType)) { throw new IllegalStateException( "Result must be parameterized" + " as Result<Foo> or Result<? extends Foo>"); } responseType = getParameterUpperBound(0, (ParameterizedType) observableType); isResult = true; } else { responseType = observableType; isBody = true; } return new RxJava2CallAdapter( responseType, scheduler, isAsync, isResult, isBody, isFlowable, isSingle, isMaybe, 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); }
@Test public void nonRxJavaTypeReturnsNull() { CallAdapter<?, ?> adapter = factory.get(String.class, NO_ANNOTATIONS, retrofit); assertThat(adapter).isNull(); } @Test public void responseTypes() { Type oBodyClass = new TypeToken<Observable<String>>() {}.getType(); assertThat(factory.get(oBodyClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sBodyClass = new TypeToken<Single<String>>() {}.getType(); assertThat(factory.get(sBodyClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type mBodyClass = new TypeToken<Maybe<String>>() {}.getType(); assertThat(factory.get(mBodyClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type fBodyClass = new TypeToken<Flowable<String>>() {}.getType(); assertThat(factory.get(fBodyClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oBodyWildcard = new TypeToken<Observable<? extends String>>() {}.getType(); assertThat(factory.get(oBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sBodyWildcard = new TypeToken<Single<? extends String>>() {}.getType(); assertThat(factory.get(sBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type mBodyWildcard = new TypeToken<Maybe<? extends String>>() {}.getType(); assertThat(factory.get(mBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type fBodyWildcard = new TypeToken<Flowable<? extends String>>() {}.getType(); assertThat(factory.get(fBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oBodyGeneric = new TypeToken<Observable<List<String>>>() {}.getType(); assertThat(factory.get(oBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(new TypeToken<List<String>>() {}.getType()); Type sBodyGeneric = new TypeToken<Single<List<String>>>() {}.getType(); assertThat(factory.get(sBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(new TypeToken<List<String>>() {}.getType()); Type mBodyGeneric = new TypeToken<Maybe<List<String>>>() {}.getType(); assertThat(factory.get(mBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(new TypeToken<List<String>>() {}.getType()); Type fBodyGeneric = new TypeToken<Flowable<List<String>>>() {}.getType(); assertThat(factory.get(fBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(new TypeToken<List<String>>() {}.getType()); Type oResponseClass = new TypeToken<Observable<Response<String>>>() {}.getType(); assertThat(factory.get(oResponseClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sResponseClass = new TypeToken<Single<Response<String>>>() {}.getType(); assertThat(factory.get(sResponseClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type mResponseClass = new TypeToken<Maybe<Response<String>>>() {}.getType(); assertThat(factory.get(mResponseClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type fResponseClass = new TypeToken<Flowable<Response<String>>>() {}.getType(); assertThat(factory.get(fResponseClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oResponseWildcard = new TypeToken<Observable<Response<? extends String>>>() {}.getType(); assertThat(factory.get(oResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sResponseWildcard = new TypeToken<Single<Response<? extends String>>>() {}.getType(); assertThat(factory.get(sResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type mResponseWildcard = new TypeToken<Maybe<Response<? extends String>>>() {}.getType(); assertThat(factory.get(mResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type fResponseWildcard = new TypeToken<Flowable<Response<? extends String>>>() {}.getType(); assertThat(factory.get(fResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oResultClass = new TypeToken<Observable<Result<String>>>() {}.getType(); assertThat(factory.get(oResultClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sResultClass = new TypeToken<Single<Result<String>>>() {}.getType(); assertThat(factory.get(sResultClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type mResultClass = new TypeToken<Maybe<Result<String>>>() {}.getType(); assertThat(factory.get(mResultClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type fResultClass = new TypeToken<Flowable<Result<String>>>() {}.getType(); assertThat(factory.get(fResultClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oResultWildcard = new TypeToken<Observable<Result<? extends String>>>() {}.getType(); assertThat(factory.get(oResultWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sResultWildcard = new TypeToken<Single<Result<? extends String>>>() {}.getType(); assertThat(factory.get(sResultWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type mResultWildcard = new TypeToken<Maybe<Result<? extends String>>>() {}.getType(); assertThat(factory.get(mResultWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type fResultWildcard = new TypeToken<Flowable<Result<? extends String>>>() {}.getType(); assertThat(factory.get(fResultWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); } @Test public void rawBodyTypeThrows() { Type observableType = new TypeToken<Observable>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage( "Observable return type must be parameterized as Observable<Foo> or Observable<? extends Foo>"); } Type singleType = new TypeToken<Single>() {}.getType(); try { factory.get(singleType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage( "Single return type must be parameterized as Single<Foo> or Single<? extends Foo>"); } Type maybeType = new TypeToken<Maybe>() {}.getType(); try { factory.get(maybeType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage( "Maybe return type must be parameterized as Maybe<Foo> or Maybe<? extends Foo>"); } Type flowableType = new TypeToken<Flowable>() {}.getType(); try { factory.get(flowableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage( "Flowable return type must be parameterized as Flowable<Foo> or Flowable<? extends Foo>"); } } @Test public void rawResponseTypeThrows() { Type observableType = new TypeToken<Observable<Response>>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } Type singleType = new TypeToken<Single<Response>>() {}.getType(); try { factory.get(singleType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } Type maybeType = new TypeToken<Maybe<Response>>() {}.getType(); try { factory.get(maybeType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } Type flowableType = new TypeToken<Flowable<Response>>() {}.getType(); try { factory.get(flowableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } } @Test public void rawResultTypeThrows() { Type observableType = new TypeToken<Observable<Result>>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Result must be parameterized as Result<Foo> or Result<? extends Foo>"); } Type singleType = new TypeToken<Single<Result>>() {}.getType(); try { factory.get(singleType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Result must be parameterized as Result<Foo> or Result<? extends Foo>"); } Type maybeType = new TypeToken<Maybe<Result>>() {}.getType(); try { factory.get(maybeType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Result must be parameterized as Result<Foo> or Result<? extends Foo>"); } Type flowableType = new TypeToken<Flowable<Result>>() {}.getType(); try { factory.get(flowableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Result must be parameterized as Result<Foo> or Result<? extends Foo>"); } }
ScalaCallAdapterFactory extends CallAdapter.Factory { @Override public @Nullable CallAdapter<?, ?> get( Type returnType, Annotation[] annotations, Retrofit retrofit) { if (getRawType(returnType) != Future.class) { return null; } if (!(returnType instanceof ParameterizedType)) { throw new IllegalStateException( "Future return type must be parameterized as Future<Foo> or Future<? extends Foo>"); } Type innerType = getParameterUpperBound(0, (ParameterizedType) returnType); if (getRawType(innerType) != Response.class) { return new BodyCallAdapter<>(innerType); } if (!(innerType instanceof ParameterizedType)) { throw new IllegalStateException( "Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } Type responseType = getParameterUpperBound(0, (ParameterizedType) innerType); return new ResponseCallAdapter<>(responseType); } private ScalaCallAdapterFactory(); static ScalaCallAdapterFactory create(); @Override @Nullable CallAdapter<?, ?> get( Type returnType, Annotation[] annotations, Retrofit retrofit); }
@Test public void responseType() { Type bodyClass = new TypeToken<Future<String>>() {}.getType(); assertThat(factory.get(bodyClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type bodyWildcard = new TypeToken<Future<? extends String>>() {}.getType(); assertThat(factory.get(bodyWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type bodyGeneric = new TypeToken<Future<List<String>>>() {}.getType(); assertThat(factory.get(bodyGeneric, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(new TypeToken<List<String>>() {}.getType()); Type responseClass = new TypeToken<Future<Response<String>>>() {}.getType(); assertThat(factory.get(responseClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type responseWildcard = new TypeToken<Future<Response<? extends String>>>() {}.getType(); assertThat(factory.get(responseWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type resultClass = new TypeToken<Future<Response<String>>>() {}.getType(); assertThat(factory.get(resultClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type resultWildcard = new TypeToken<Future<Response<? extends String>>>() {}.getType(); assertThat(factory.get(resultWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); } @Test public void nonListenableFutureReturnsNull() { CallAdapter<?, ?> adapter = factory.get(String.class, NO_ANNOTATIONS, retrofit); assertThat(adapter).isNull(); } @Test public void rawTypeThrows() { Type observableType = new TypeToken<Future>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage( "Future return type must be parameterized as Future<Foo> or Future<? extends Foo>"); } } @Test public void rawResponseTypeThrows() { Type observableType = new TypeToken<Future<Response>>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } }
Java8CallAdapterFactory extends CallAdapter.Factory { @Override public @Nullable CallAdapter<?, ?> get( Type returnType, Annotation[] annotations, Retrofit retrofit) { if (getRawType(returnType) != CompletableFuture.class) { return null; } if (!(returnType instanceof ParameterizedType)) { throw new IllegalStateException( "CompletableFuture return type must be parameterized" + " as CompletableFuture<Foo> or CompletableFuture<? extends Foo>"); } Type innerType = getParameterUpperBound(0, (ParameterizedType) returnType); if (getRawType(innerType) != Response.class) { return new BodyCallAdapter<>(innerType); } if (!(innerType instanceof ParameterizedType)) { throw new IllegalStateException( "Response must be parameterized" + " as Response<Foo> or Response<? extends Foo>"); } Type responseType = getParameterUpperBound(0, (ParameterizedType) innerType); return new ResponseCallAdapter<>(responseType); } private Java8CallAdapterFactory(); static Java8CallAdapterFactory create(); @Override @Nullable CallAdapter<?, ?> get( Type returnType, Annotation[] annotations, Retrofit retrofit); }
@Test public void responseType() { Type bodyClass = new TypeToken<CompletableFuture<String>>() {}.getType(); assertThat(factory.get(bodyClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type bodyWildcard = new TypeToken<CompletableFuture<? extends String>>() {}.getType(); assertThat(factory.get(bodyWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type bodyGeneric = new TypeToken<CompletableFuture<List<String>>>() {}.getType(); assertThat(factory.get(bodyGeneric, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(new TypeToken<List<String>>() {}.getType()); Type responseClass = new TypeToken<CompletableFuture<Response<String>>>() {}.getType(); assertThat(factory.get(responseClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type responseWildcard = new TypeToken<CompletableFuture<Response<? extends String>>>() {}.getType(); assertThat(factory.get(responseWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type resultClass = new TypeToken<CompletableFuture<Response<String>>>() {}.getType(); assertThat(factory.get(resultClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type resultWildcard = new TypeToken<CompletableFuture<Response<? extends String>>>() {}.getType(); assertThat(factory.get(resultWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); } @Test public void nonListenableFutureReturnsNull() { CallAdapter<?, ?> adapter = factory.get(String.class, NO_ANNOTATIONS, retrofit); assertThat(adapter).isNull(); } @Test public void rawTypeThrows() { Type observableType = new TypeToken<CompletableFuture>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage( "CompletableFuture return type must be parameterized as CompletableFuture<Foo> or CompletableFuture<? extends Foo>"); } } @Test public void rawResponseTypeThrows() { Type observableType = new TypeToken<CompletableFuture<Response>>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } }
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); }
@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"); }
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); }
@Test public void nullSchedulerThrows() { try { RxJavaCallAdapterFactory.createWithScheduler(null); fail(); } catch (NullPointerException e) { assertThat(e).hasMessage("scheduler == null"); } }
RxJavaCallAdapterFactory extends CallAdapter.Factory { @Override public @Nullable CallAdapter<?, ?> get( Type returnType, Annotation[] annotations, Retrofit retrofit) { Class<?> rawType = getRawType(returnType); boolean isSingle = rawType == Single.class; boolean isCompletable = rawType == Completable.class; if (rawType != Observable.class && !isSingle && !isCompletable) { return null; } if (isCompletable) { return new RxJavaCallAdapter(Void.class, scheduler, isAsync, false, true, false, true); } boolean isResult = false; boolean isBody = false; Type responseType; if (!(returnType instanceof ParameterizedType)) { String name = isSingle ? "Single" : "Observable"; throw new IllegalStateException( name + " return type must be parameterized" + " as " + name + "<Foo> or " + name + "<? extends Foo>"); } Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType); Class<?> rawObservableType = getRawType(observableType); if (rawObservableType == Response.class) { if (!(observableType instanceof ParameterizedType)) { throw new IllegalStateException( "Response must be parameterized" + " as Response<Foo> or Response<? extends Foo>"); } responseType = getParameterUpperBound(0, (ParameterizedType) observableType); } else if (rawObservableType == Result.class) { if (!(observableType instanceof ParameterizedType)) { throw new IllegalStateException( "Result must be parameterized" + " as Result<Foo> or Result<? extends Foo>"); } responseType = getParameterUpperBound(0, (ParameterizedType) observableType); isResult = true; } else { responseType = observableType; isBody = true; } return new RxJavaCallAdapter( responseType, scheduler, isAsync, isResult, isBody, isSingle, 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); }
@Test public void nonRxJavaTypeReturnsNull() { CallAdapter<?, ?> adapter = factory.get(String.class, NO_ANNOTATIONS, retrofit); assertThat(adapter).isNull(); } @Test public void responseTypes() { Type oBodyClass = new TypeToken<Observable<String>>() {}.getType(); assertThat(factory.get(oBodyClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sBodyClass = new TypeToken<Single<String>>() {}.getType(); assertThat(factory.get(sBodyClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oBodyWildcard = new TypeToken<Observable<? extends String>>() {}.getType(); assertThat(factory.get(oBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sBodyWildcard = new TypeToken<Single<? extends String>>() {}.getType(); assertThat(factory.get(sBodyWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oBodyGeneric = new TypeToken<Observable<List<String>>>() {}.getType(); assertThat(factory.get(oBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(new TypeToken<List<String>>() {}.getType()); Type sBodyGeneric = new TypeToken<Single<List<String>>>() {}.getType(); assertThat(factory.get(sBodyGeneric, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(new TypeToken<List<String>>() {}.getType()); Type oResponseClass = new TypeToken<Observable<Response<String>>>() {}.getType(); assertThat(factory.get(oResponseClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sResponseClass = new TypeToken<Single<Response<String>>>() {}.getType(); assertThat(factory.get(sResponseClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oResponseWildcard = new TypeToken<Observable<Response<? extends String>>>() {}.getType(); assertThat(factory.get(oResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sResponseWildcard = new TypeToken<Single<Response<? extends String>>>() {}.getType(); assertThat(factory.get(sResponseWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oResultClass = new TypeToken<Observable<Result<String>>>() {}.getType(); assertThat(factory.get(oResultClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sResultClass = new TypeToken<Single<Result<String>>>() {}.getType(); assertThat(factory.get(sResultClass, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type oResultWildcard = new TypeToken<Observable<Result<? extends String>>>() {}.getType(); assertThat(factory.get(oResultWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); Type sResultWildcard = new TypeToken<Single<Result<? extends String>>>() {}.getType(); assertThat(factory.get(sResultWildcard, NO_ANNOTATIONS, retrofit).responseType()) .isEqualTo(String.class); } @Test public void rawBodyTypeThrows() { Type observableType = new TypeToken<Observable>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage( "Observable return type must be parameterized as Observable<Foo> or Observable<? extends Foo>"); } Type singleType = new TypeToken<Single>() {}.getType(); try { factory.get(singleType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage( "Single return type must be parameterized as Single<Foo> or Single<? extends Foo>"); } } @Test public void rawResponseTypeThrows() { Type observableType = new TypeToken<Observable<Response>>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } Type singleType = new TypeToken<Single<Response>>() {}.getType(); try { factory.get(singleType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>"); } } @Test public void rawResultTypeThrows() { Type observableType = new TypeToken<Observable<Result>>() {}.getType(); try { factory.get(observableType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Result must be parameterized as Result<Foo> or Result<? extends Foo>"); } Type singleType = new TypeToken<Single<Result>>() {}.getType(); try { factory.get(singleType, NO_ANNOTATIONS, retrofit); fail(); } catch (IllegalStateException e) { assertThat(e) .hasMessage("Result must be parameterized as Result<Foo> or Result<? extends Foo>"); } }