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
NativeClient implements Client { @Override public void disconnect() { logging.info("Client disconnect requested"); logging.debug("This Client will now try to acquire nearly everything."); logging.trace("Acquiring ConnectionMap"); synchronized (connectionMap) { logging.trace("Acquiring DisconnectedPipeline"); synchronized (disconnectedPipeline) { logging.trace("Acquiring SessionValue"); synchronized (sessionValue) { logging.trace("Acquiring primed Synchronize"); synchronized (synchronize) { logging.trace("Disconnecting all Connections"); for (Class<?> key : connectionMap.keySet()) { logging.trace("Trying to disconnect " + key); try { connectionMap.remove(key).close(); logging.trace(key + " removed and disconnected"); } catch (IOException e) { logging.error("Disconnect of " + key + " failed!", e); } } logging.trace("Clearing left over artifacts"); connectionMap.clear(); } logging.trace("Calling DisconnectedPipeline"); disconnectedPipeline.apply(this); logging.trace("Clearing DisconnectedPipeline"); disconnectedPipeline.clear(); logging.trace("Clearing SessionValue"); sessionValue.clear(); logging.trace("Resetting Primed Synchronize"); synchronize.reset(); } } } logging.info("Client has been disconnected"); } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test public void disconnect() throws Exception { NativeClient client = new NativeClient(registration); Connection mockedConnection = mock(Connection.class); client.setConnection(TestConnectionKey.class, mockedConnection); Session session = client.getSession(); client.disconnect(); verify(mockedConnection).close(); assertFalse(client.getConnection(TestConnectionKey.class).isPresent()); assertEquals(session, client.getSession()); assertTrue(ClientID.isEmpty(client.getID())); }
NativeClient implements Client { @Override public Session getSession() { synchronized (sessionValue) { return sessionValue.get(); } } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test public void getSession() throws Exception { NativeClient client = new NativeClient(registration); Session session = client.getSession(); assertNull(session); }
NativeClient implements Client { @Override public void setSession(final Session session) { synchronized (sessionValue) { sessionValue.set(session); } } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test public void setSession() throws Exception { NativeClient client = new NativeClient(registration); Session prev = client.getSession(); client.setSession(mock(Session.class)); assertNotEquals(prev, client.getSession()); }
NativeClient implements Client { @Override public void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler) { synchronized (disconnectedPipeline) { disconnectedPipeline.add(disconnectedHandler); } } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test(expected = IllegalArgumentException.class) public void addDisconnectedHandlerNull() throws Exception { NativeClient client = new NativeClient(registration); client.addDisconnectedHandler(null); fail(); }
NativeClient implements Client { @Override public void send(Object object, Connection connection) { logging.debug("Sending over the provided Connection"); logging.trace("Converting set Object to writable String"); String string = convert(object); logging.trace("Extracting send as Task to the NetComThreadPool"); NetComThreadPool.submitTask(new Runnable() { @Override public void run() { try { logging.trace("Checking connection to send to .."); if (!connection.isConnected()) { logging.debug("Awaiting finish of Connection"); System.out.println("Awaiting finish of Connection"); connection.connected().synchronize(); logging.debug("Connection is now connected"); } logging.trace("Connection is set up, performing requested write"); connection.write(string.getBytes()); } catch (InterruptedException e) { throw new SendFailedException(e); } } @Override public String toString() { return "Task{Write=" + object + "}"; } }); } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test(expected = SendFailedException.class) public void send() throws Exception { NativeClient client = new NativeClient(registration); Connection connection = mock(Connection.class); when(connection.isOpen()).thenReturn(true); when(connection.isConnected()).thenReturn(true); client.setConnection(DefaultConnection.class, connection); TestObject object = new TestObject(); client.send(object); verify(connection).write(any(String.class)); } @Test @Ignore public void send2() throws Exception { NativeClient client = new NativeClient(registration); Connection connection = mock(Connection.class); when(connection.isOpen()).thenReturn(true); when(connection.isConnected()).thenReturn(true); TestObject object = new TestObject(); client.send(object, connection); verify(connection).write(any(String.class)); }
JavaRemoteInformationInvocationHandler implements RemoteObjectHandler { public <S extends T> void setFallbackInstance(S fallbackInstance) { synchronized (this) { this.fallbackInstance = fallbackInstance; this.fallbackRunnable = null; } } @APILevel JavaRemoteInformationInvocationHandler(final Sender sender, final RemoteAccessBlockRegistration remoteAccessBlockRegistration, final Class<T> clazz, final UUID uuid); @Override Object invoke(final Object proxy, final Method method, final Object[] args); void setFallbackRunnable(Runnable fallbackRunnable); void setFallbackInstance(S fallbackInstance); }
@Test public void setFallbackInstance() throws Throwable { UUID id = UUID.randomUUID(); Sender sender = mock(Sender.class); AtomicBoolean done = new AtomicBoolean(false); doThrow(new SendFailedException("MockedSendFailed")).when(sender).objectToServer(any()); RemoteAccessBlockRegistration registration = mock(RemoteAccessBlockRegistration.class); JavaRemoteInformationInvocationHandler<TestInterface> handler = new JavaRemoteInformationInvocationHandler<>(sender, registration, TestInterface.class, id); handler.setFallbackInstance(() -> done.set(true)); handler.invoke(null, TestInterface.class.getMethod("testMethod"), new Object[0]); verify(sender, atLeastOnce()).objectToServer(any(RemoteAccessCommunicationRequest.class)); assertTrue(done.get()); }
NativeClient implements Client { @Override public Optional<Connection> getConnection(Class connectionKey) { synchronized (connectionMap) { return Optional.ofNullable(connectionMap.get(connectionKey)); } } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test public void getConnectionNotSet() throws Exception { NativeClient client = new NativeClient(registration); Optional<Connection> optional = client.getConnection(TestConnectionKey.class); assertFalse(optional.isPresent()); } @Test public void getConnection() throws Exception { NativeClient client = new NativeClient(registration); Connection connection = mock(Connection.class); client.setConnection(TestConnectionKey.class, connection); Optional<Connection> optional = client.getConnection(TestConnectionKey.class); assertTrue(optional.isPresent()); assertEquals(connection, optional.get()); }
NativeClient implements Client { @Override public void setConnection(Class<?> identifier, Connection connection) { NetCom2Utils.parameterNotNull(identifier, connection); synchronized (connectionMap) { connectionMap.put(identifier, connection); } connection.addShutdownHook(this::removeConnection); } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test @Ignore public void createNewConnection() throws Exception { NativeClient client = new NativeClient(registration); Connection connection = mock(Connection.class); when(connection.isOpen()).thenReturn(true); when(connection.isConnected()).thenReturn(true); client.setConnection(DefaultConnection.class, connection); client.createNewConnection(TestConnectionKey.class); verify(connection).write(any(byte[].class)); } @Test public void setConnection() throws Exception { NativeClient client = new NativeClient(registration); Connection connection = mock(Connection.class); client.setConnection(TestConnectionKey.class, connection); Optional<Connection> optional = client.getConnection(TestConnectionKey.class); assertTrue(optional.isPresent()); assertSame(connection, optional.get()); }
NativeClient implements Client { @Override public ClientID getID() { return clientID; } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test public void getID() throws Exception { NativeClient client = new NativeClient(registration); ClientID id = client.getID(); assertTrue(ClientID.isEmpty(id)); }
NativeClient implements Client { @Override public void setID(ClientID id) { clientID.updateBy(id); } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test public void setID() throws Exception { NativeClient client = new NativeClient(registration); ClientID id = client.getID(); client.setID(ClientID.fromString(TestUtils.UUID_SEED_1)); assertEquals(id, client.getID()); }
NativeClient implements Client { @Override public void routeConnection(Class originalKey, Class newKey) { NetCom2Utils.parameterNotNull(originalKey); logging.debug("Routing " + originalKey.getSimpleName() + " to " + newKey); synchronized (connectionMap) { if (connectionMap.get(originalKey) == null) { logging.warn("No Connection set for " + originalKey); return; } if (connectionMap.get(newKey) != null) { logging.warn("Overriding the previous instance for " + newKey); } Connection connection = connectionMap.get(originalKey); connectionMap.put(newKey, connection); } } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test public void routeConnection() throws Exception { NativeClient client = new NativeClient(registration); Connection connection = mock(Connection.class); client.setConnection(DefaultConnection.class, connection); client.routeConnection(DefaultConnection.class, TestConnectionKey.class); Optional<Connection> optional = client.getConnection(TestConnectionKey.class); assertTrue(optional.isPresent()); assertSame(connection, optional.get()); }
NativeClient implements Client { @Override public CommunicationRegistration getCommunicationRegistration() { return communicationRegistration; } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test public void getCommunicationRegistration() throws Exception { NativeClient client = new NativeClient(registration); CommunicationRegistration communicationRegistration = client.getCommunicationRegistration(); assertNotNull(communicationRegistration); }
NativeClient implements Client { @Override public Awaiting prepareConnection(Class clazz) { NetCom2Utils.parameterNotNull(clazz); logging.debug("Trying to prepare for " + clazz); synchronized (prepared) { prepared.computeIfAbsent(clazz, key -> Synchronize.createDefault()); return prepared.get(clazz); } } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test public void prepareConnection() throws Exception { NativeClient client = new NativeClient(registration); Awaiting awaiting = client.prepareConnection(TestConnectionKey.class); assertNotNull(awaiting); assertFalse(Synchronize.isEmpty(awaiting)); } @Test public void prepareConnectionDouble() throws Exception { NativeClient client = new NativeClient(registration); Awaiting awaiting = client.prepareConnection(TestConnectionKey.class); Awaiting awaitingTwo = client.prepareConnection(TestConnectionKey.class); assertSame(awaiting, awaitingTwo); } @Test(expected = IllegalArgumentException.class) public void prepareConnectionNull() throws Exception { NativeClient client = new NativeClient(registration); client.prepareConnection(null); fail(); }
RemoteAccessBlockRegistration { @APILevel void clearSemaphore(UUID uuid) { NetCom2Utils.parameterNotNull(uuid); synchronized (semaphoreMap) { semaphoreMap.remove(uuid); } } RemoteAccessBlockRegistration(); }
@Test public void clearSemaphore() throws Exception { RemoteAccessBlockRegistration registration = new RemoteAccessBlockRegistration(); UUID id = UUID.randomUUID(); Semaphore semaphore = registration.await(new RemoteAccessCommunicationRequest("", Example.class, id, new Object[0])); registration.release(new RemoteAccessCommunicationResponse(id, null, null)); registration.clearSemaphore(id); assertEquals(1, semaphore.availablePermits()); assertEquals(0, registration.countSemaphores()); assertEquals(1, registration.countResponses()); }
NativeClient implements Client { @Override public void connectionPrepared(Class<?> identifier) { logging.debug("Releasing all Threads, waiting for the preparation of the Connection " + identifier); synchronized (prepared) { logging.trace("Fetching Synchronize"); Synchronize synchronize = prepared.remove(identifier); logging.trace("Performing sanity-check in Synchronize"); if (synchronize != null) { logging.trace("Found Synchronize .. Releasing waiting Threads .."); synchronize.goOn(); logging.info("Released all waiting Threads for " + identifier); } else { logging.error("No Connection has been prepared for the Class " + identifier); throw new IllegalArgumentException("No Connection set for " + identifier); } } } NativeClient(CommunicationRegistration communicationRegistration); @Override void removeConnection(Connection connection); @Override void addConnection(Connection connection); @Override void setConnection(Class<?> identifier, Connection connection); @Override void routeConnection(Class originalKey, Class newKey); @Override void routeConnection(Connection originalConnection, Class newKey); @Override Optional<Connection> getConnection(Class connectionKey); @Override void disconnect(); @Override Session getSession(); @Override void setSession(final Session session); @Override CommunicationRegistration getCommunicationRegistration(); @Override Awaiting primed(); @Override boolean isPrimed(); @Override void triggerPrimed(); @Override ClientID getID(); @Override void setID(ClientID id); @Override void receive(RawData rawData, Connection connection); @Override void addDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void removeDisconnectedHandler(ClientDisconnectedHandler disconnectedHandler); @Override void addPrimedCallback(Consumer<Client> clientConsumer); @Override ObjectHandler objectHandler(); @Override void sendIgnoreConstraints(Object object, Connection connection); @Override void send(Object object, Connection connection); @Override void send(Object object, Class<?> connectionKey); @Override void send(Object object); @Override String getFormattedAddress(); @Override void overridePrepareConnection(Class clazz, Synchronize synchronize); @Override Synchronize accessPrepareConnection(Class clazz); @Override Awaiting prepareConnection(Class clazz); @Override void connectionPrepared(Class<?> identifier); @Override void invalidate(); @Override String toString(); }
@Test(expected = IllegalArgumentException.class) public void notifyAboutPreparedConnectionNotPrepared() throws Exception { NativeClient client = new NativeClient(registration); client.connectionPrepared(TestConnectionKey.class); fail(); } @Test(expected = IllegalArgumentException.class) public void notifyAboutPreparedConnectionNull() throws Exception { NativeClient client = new NativeClient(registration); client.connectionPrepared(null); fail(); }
NativeSession implements Session { @Override public boolean isIdentified() { return identifiedValue.get(); } NativeSession(SendBridge sendBridge); @Override boolean isIdentified(); @Override void setIdentified(boolean identified); @Override String getIdentifier(); @Override void setIdentifier(String identifier); @Override Properties getProperties(); @Override void setProperties(Properties properties); @Override void send(Object o); @Override void triggerPrimed(); @Override Awaiting primed(); @Override void resetPrimed(); @Override void acquire(); @Override void release(); @Override String toString(); }
@Test public void isIdentified() throws Exception { NativeSession session = new NativeSession(bridge); boolean isIdentified = session.isIdentified(); assertFalse(isIdentified); }
NativeSession implements Session { @Override public void setIdentified(boolean identified) { identifiedValue.set(identified); } NativeSession(SendBridge sendBridge); @Override boolean isIdentified(); @Override void setIdentified(boolean identified); @Override String getIdentifier(); @Override void setIdentifier(String identifier); @Override Properties getProperties(); @Override void setProperties(Properties properties); @Override void send(Object o); @Override void triggerPrimed(); @Override Awaiting primed(); @Override void resetPrimed(); @Override void acquire(); @Override void release(); @Override String toString(); }
@Test public void setIdentified() throws Exception { NativeSession session = new NativeSession(bridge); session.setIdentified(true); assertTrue(session.isIdentified()); }
NativeSession implements Session { @Override public String getIdentifier() { return identifierValue.get(); } NativeSession(SendBridge sendBridge); @Override boolean isIdentified(); @Override void setIdentified(boolean identified); @Override String getIdentifier(); @Override void setIdentifier(String identifier); @Override Properties getProperties(); @Override void setProperties(Properties properties); @Override void send(Object o); @Override void triggerPrimed(); @Override Awaiting primed(); @Override void resetPrimed(); @Override void acquire(); @Override void release(); @Override String toString(); }
@Test public void getIdentifier() throws Exception { NativeSession session = new NativeSession(bridge); String identifier = session.getIdentifier(); assertEquals("", identifier); }
NativeSession implements Session { @Override public void setIdentifier(String identifier) { identifierValue.set(identifier); } NativeSession(SendBridge sendBridge); @Override boolean isIdentified(); @Override void setIdentified(boolean identified); @Override String getIdentifier(); @Override void setIdentifier(String identifier); @Override Properties getProperties(); @Override void setProperties(Properties properties); @Override void send(Object o); @Override void triggerPrimed(); @Override Awaiting primed(); @Override void resetPrimed(); @Override void acquire(); @Override void release(); @Override String toString(); }
@Test public void setIdentifier() throws Exception { NativeSession session = new NativeSession(bridge); session.setIdentifier("TEST"); assertEquals("TEST", session.getIdentifier()); } @Test(expected = IllegalArgumentException.class) public void setIdentifierNull() throws Exception { NativeSession session = new NativeSession(bridge); session.setIdentifier(null); fail(); }
NativeSession implements Session { @Override public Properties getProperties() { return propertiesValue.get(); } NativeSession(SendBridge sendBridge); @Override boolean isIdentified(); @Override void setIdentified(boolean identified); @Override String getIdentifier(); @Override void setIdentifier(String identifier); @Override Properties getProperties(); @Override void setProperties(Properties properties); @Override void send(Object o); @Override void triggerPrimed(); @Override Awaiting primed(); @Override void resetPrimed(); @Override void acquire(); @Override void release(); @Override String toString(); }
@Test public void getProperties() throws Exception { NativeSession session = new NativeSession(bridge); Properties properties = session.getProperties(); assertTrue(properties.isEmpty()); }
NativeSession implements Session { @Override public void setProperties(Properties properties) { propertiesValue.set(properties); } NativeSession(SendBridge sendBridge); @Override boolean isIdentified(); @Override void setIdentified(boolean identified); @Override String getIdentifier(); @Override void setIdentifier(String identifier); @Override Properties getProperties(); @Override void setProperties(Properties properties); @Override void send(Object o); @Override void triggerPrimed(); @Override Awaiting primed(); @Override void resetPrimed(); @Override void acquire(); @Override void release(); @Override String toString(); }
@Test public void setProperties() throws Exception { NativeSession session = new NativeSession(bridge); Properties newProperties = new Properties(); session.setProperties(newProperties); assertEquals(newProperties, session.getProperties()); assertSame(newProperties, session.getProperties()); } @Test(expected = IllegalArgumentException.class) public void setPropertiesNull() throws Exception { NativeSession session = new NativeSession(bridge); session.setProperties(null); fail(); }
RemoteAccessBlockRegistration { @APILevel void clearResult(UUID uuid) { NetCom2Utils.parameterNotNull(uuid); synchronized (responseMap) { responseMap.remove(uuid); } } RemoteAccessBlockRegistration(); }
@Test public void clearResult() throws Exception { RemoteAccessBlockRegistration registration = new RemoteAccessBlockRegistration(); UUID id = UUID.randomUUID(); Semaphore semaphore = registration.await(new RemoteAccessCommunicationRequest("", Example.class, id, new Object[0])); registration.release(new RemoteAccessCommunicationResponse(id, null, null)); registration.clearResult(id); assertEquals(1, semaphore.availablePermits()); assertEquals(1, registration.countSemaphores()); assertEquals(0, registration.countResponses()); }
NativeSession implements Session { @Override public void send(Object o) { NetCom2Utils.parameterNotNull(o); sendBridge.send(o); } NativeSession(SendBridge sendBridge); @Override boolean isIdentified(); @Override void setIdentified(boolean identified); @Override String getIdentifier(); @Override void setIdentifier(String identifier); @Override Properties getProperties(); @Override void setProperties(Properties properties); @Override void send(Object o); @Override void triggerPrimed(); @Override Awaiting primed(); @Override void resetPrimed(); @Override void acquire(); @Override void release(); @Override String toString(); }
@Test public void send() throws Exception { NativeSession session = new NativeSession(bridge); TestObject testObject = new TestObject(); session.send(testObject); verify(bridge).send(eq(testObject)); } @Test(expected = IllegalArgumentException.class) public void sendNull() throws Exception { NativeSession session = new NativeSession(bridge); session.send(null); fail(); }
NativeSession implements Session { @Override public Awaiting primed() { return synchronize; } NativeSession(SendBridge sendBridge); @Override boolean isIdentified(); @Override void setIdentified(boolean identified); @Override String getIdentifier(); @Override void setIdentifier(String identifier); @Override Properties getProperties(); @Override void setProperties(Properties properties); @Override void send(Object o); @Override void triggerPrimed(); @Override Awaiting primed(); @Override void resetPrimed(); @Override void acquire(); @Override void release(); @Override String toString(); }
@Test public void primed() throws Exception { NativeSession session = new NativeSession(bridge); Awaiting awaiting = session.primed(); assertFalse(Synchronize.isEmpty(awaiting)); }
NativeCache extends CacheObservable implements Cache { @Override public void addNew(final Object object) { logging.trace("Trying to add a new Object(" + object + ") to Cache .."); NetCom2Utils.parameterNotNull(object); if (!isSet(object.getClass())) { synchronized (internals) { internals.put(object.getClass(), object); logging.debug("Added new entry for " + object.getClass()); } notifyAboutNewEntry(object); } else { logging.warn(object.getClass() + " is already set!"); } } NativeCache(); @Override void update(final Object object); @Override void addNew(final Object object); @Override void addAndOverride(final Object object); @Override void remove(final Class clazz); @Override @SuppressWarnings("unchecked") Optional<T> get(final Class<T> clazz); @Override boolean isSet(final Class<?> clazz); @Override void addCacheObserver(final CacheObserver<T> cacheObserver); @Override void removeCacheObserver(final CacheObserver<T> cacheObserver); @Override void addGeneralObserver(final GeneralCacheObserver observer); @Override void removeGeneralObserver(final GeneralCacheObserver observer); @Override void clearObservers(); @Override void reset(); @Override String toString(); @Override void acquire(); @Override void release(); }
@Test public void addNew() throws Exception { NativeCache cache = new NativeCache(); CacheElement element = new CacheElement(); cache.addNew(element); Optional<CacheElement> optional = cache.get(CacheElement.class); assertTrue(optional.isPresent()); assertSame(element, optional.get()); }
NativeCache extends CacheObservable implements Cache { @Override public void addAndOverride(final Object object) { NetCom2Utils.parameterNotNull(object); if (!isSet(object.getClass())) { addNew(object); } else { update(object); } } NativeCache(); @Override void update(final Object object); @Override void addNew(final Object object); @Override void addAndOverride(final Object object); @Override void remove(final Class clazz); @Override @SuppressWarnings("unchecked") Optional<T> get(final Class<T> clazz); @Override boolean isSet(final Class<?> clazz); @Override void addCacheObserver(final CacheObserver<T> cacheObserver); @Override void removeCacheObserver(final CacheObserver<T> cacheObserver); @Override void addGeneralObserver(final GeneralCacheObserver observer); @Override void removeGeneralObserver(final GeneralCacheObserver observer); @Override void clearObservers(); @Override void reset(); @Override String toString(); @Override void acquire(); @Override void release(); }
@Test public void addAndOverride() throws Exception { NativeCache cache = new NativeCache(); CacheElement element = new CacheElement(); cache.addAndOverride(element); Optional<CacheElement> optional = cache.get(CacheElement.class); assertTrue(optional.isPresent()); assertSame(element, optional.get()); }
NativeCache extends CacheObservable implements Cache { @Override public void remove(final Class clazz) { logging.trace("Trying to isRemovable Object(" + clazz + ") to Cache .."); NetCom2Utils.parameterNotNull(clazz); if (isSet(clazz)) { final Object removedEntry; synchronized (internals) { removedEntry = internals.remove(clazz); } logging.debug("Removed entry for " + clazz + " (instance: " + removedEntry + ")"); notifyAboutRemovedEntry(removedEntry); } } NativeCache(); @Override void update(final Object object); @Override void addNew(final Object object); @Override void addAndOverride(final Object object); @Override void remove(final Class clazz); @Override @SuppressWarnings("unchecked") Optional<T> get(final Class<T> clazz); @Override boolean isSet(final Class<?> clazz); @Override void addCacheObserver(final CacheObserver<T> cacheObserver); @Override void removeCacheObserver(final CacheObserver<T> cacheObserver); @Override void addGeneralObserver(final GeneralCacheObserver observer); @Override void removeGeneralObserver(final GeneralCacheObserver observer); @Override void clearObservers(); @Override void reset(); @Override String toString(); @Override void acquire(); @Override void release(); }
@Test public void remove() throws Exception { NativeCache cache = new NativeCache(); cache.remove(CacheElement.class); Optional<CacheElement> optional = cache.get(CacheElement.class); assertFalse(optional.isPresent()); }
NativeCache extends CacheObservable implements Cache { @Override @SuppressWarnings("unchecked") public <T> Optional<T> get(final Class<T> clazz) { NetCom2Utils.parameterNotNull(clazz); final Object retrieved; synchronized (internals) { retrieved = internals.get(clazz); } if (retrieved != null && retrieved.getClass().equals(clazz)) { return Optional.of((T) retrieved); } return Optional.empty(); } NativeCache(); @Override void update(final Object object); @Override void addNew(final Object object); @Override void addAndOverride(final Object object); @Override void remove(final Class clazz); @Override @SuppressWarnings("unchecked") Optional<T> get(final Class<T> clazz); @Override boolean isSet(final Class<?> clazz); @Override void addCacheObserver(final CacheObserver<T> cacheObserver); @Override void removeCacheObserver(final CacheObserver<T> cacheObserver); @Override void addGeneralObserver(final GeneralCacheObserver observer); @Override void removeGeneralObserver(final GeneralCacheObserver observer); @Override void clearObservers(); @Override void reset(); @Override String toString(); @Override void acquire(); @Override void release(); }
@Test public void get() throws Exception { NativeCache cache = new NativeCache(); CacheElement element = new CacheElement(); cache.addNew(element); Optional<CacheElement> optional = cache.get(CacheElement.class); assertNotNull(optional); assertTrue(optional.isPresent()); assertSame(element, optional.get()); } @Test public void getEmpty() throws Exception { NativeCache cache = new NativeCache(); Optional<CacheElement> optional = cache.get(CacheElement.class); assertFalse(optional.isPresent()); }
NativeCache extends CacheObservable implements Cache { @Override public boolean isSet(final Class<?> clazz) { NetCom2Utils.parameterNotNull(clazz); return get(clazz).isPresent(); } NativeCache(); @Override void update(final Object object); @Override void addNew(final Object object); @Override void addAndOverride(final Object object); @Override void remove(final Class clazz); @Override @SuppressWarnings("unchecked") Optional<T> get(final Class<T> clazz); @Override boolean isSet(final Class<?> clazz); @Override void addCacheObserver(final CacheObserver<T> cacheObserver); @Override void removeCacheObserver(final CacheObserver<T> cacheObserver); @Override void addGeneralObserver(final GeneralCacheObserver observer); @Override void removeGeneralObserver(final GeneralCacheObserver observer); @Override void clearObservers(); @Override void reset(); @Override String toString(); @Override void acquire(); @Override void release(); }
@Test public void isSet() throws Exception { NativeCache cache = new NativeCache(); boolean isSet = cache.isSet(CacheElement.class); assertFalse(isSet); }
RemoteAccessBlockRegistration { @APILevel Semaphore await(RemoteAccessCommunicationRequest request) { NetCom2Utils.parameterNotNull(request); Semaphore semaphore = getAndCreateSemaphore(request.getUuid()); responseMap.remove(request.getUuid()); return semaphore; } RemoteAccessBlockRegistration(); }
@Test public void await() throws Exception { RemoteAccessBlockRegistration registration = new RemoteAccessBlockRegistration(); UUID id = UUID.randomUUID(); Semaphore semaphore = registration.await(new RemoteAccessCommunicationRequest("", Example.class, id, new Object[0])); assertEquals(0, semaphore.availablePermits()); }
NativeCache extends CacheObservable implements Cache { @Override public <T> void addCacheObserver(final CacheObserver<T> cacheObserver) { logging.debug("Adding CacheObserver(" + cacheObserver + ") to " + toString()); NetCom2Utils.parameterNotNull(cacheObserver); addObserver(cacheObserver); } NativeCache(); @Override void update(final Object object); @Override void addNew(final Object object); @Override void addAndOverride(final Object object); @Override void remove(final Class clazz); @Override @SuppressWarnings("unchecked") Optional<T> get(final Class<T> clazz); @Override boolean isSet(final Class<?> clazz); @Override void addCacheObserver(final CacheObserver<T> cacheObserver); @Override void removeCacheObserver(final CacheObserver<T> cacheObserver); @Override void addGeneralObserver(final GeneralCacheObserver observer); @Override void removeGeneralObserver(final GeneralCacheObserver observer); @Override void clearObservers(); @Override void reset(); @Override String toString(); @Override void acquire(); @Override void release(); }
@Test public void addCacheObserver() throws Exception { NativeCache cache = new NativeCache(); CacheObserver<CacheElement> observer = new AbstractCacheObserver<CacheElement>(CacheElement.class) { @Override public void newEntry(final CacheElement cacheElement, final CacheObservable observable) { } @Override public void updatedEntry(final CacheElement cacheElement, final CacheObservable observable) { } @Override public void deletedEntry(final CacheElement cacheElement, final CacheObservable observable) { } }; cache.addCacheObserver(observer); assertEquals(1, cache.countObservers()); }
NativeCache extends CacheObservable implements Cache { @Override public <T> void removeCacheObserver(final CacheObserver<T> cacheObserver) { logging.debug("Removing CacheObserver(" + cacheObserver + ") from " + toString()); NetCom2Utils.parameterNotNull(cacheObserver); deleteObserver(cacheObserver); } NativeCache(); @Override void update(final Object object); @Override void addNew(final Object object); @Override void addAndOverride(final Object object); @Override void remove(final Class clazz); @Override @SuppressWarnings("unchecked") Optional<T> get(final Class<T> clazz); @Override boolean isSet(final Class<?> clazz); @Override void addCacheObserver(final CacheObserver<T> cacheObserver); @Override void removeCacheObserver(final CacheObserver<T> cacheObserver); @Override void addGeneralObserver(final GeneralCacheObserver observer); @Override void removeGeneralObserver(final GeneralCacheObserver observer); @Override void clearObservers(); @Override void reset(); @Override String toString(); @Override void acquire(); @Override void release(); }
@Test public void removeCacheObserver() throws Exception { NativeCache cache = new NativeCache(); CacheObserver<CacheElement> observer = new AbstractCacheObserver<CacheElement>(CacheElement.class) { @Override public void newEntry(final CacheElement cacheElement, final CacheObservable observable) { fail(); } @Override public void updatedEntry(final CacheElement cacheElement, final CacheObservable observable) { fail(); } @Override public void deletedEntry(final CacheElement cacheElement, final CacheObservable observable) { fail(); } }; cache.addCacheObserver(observer); cache.removeCacheObserver(observer); cache.addAndOverride(new CacheElement()); assertEquals(0, cache.countObservers()); }
NativeCache extends CacheObservable implements Cache { @Override public void addGeneralObserver(final GeneralCacheObserver observer) { logging.debug("Adding Observer(" + observer + ") to " + toString()); logging.warn("It is recommended to use " + CacheObserver.class); NetCom2Utils.parameterNotNull(observer); addObserver(observer); } NativeCache(); @Override void update(final Object object); @Override void addNew(final Object object); @Override void addAndOverride(final Object object); @Override void remove(final Class clazz); @Override @SuppressWarnings("unchecked") Optional<T> get(final Class<T> clazz); @Override boolean isSet(final Class<?> clazz); @Override void addCacheObserver(final CacheObserver<T> cacheObserver); @Override void removeCacheObserver(final CacheObserver<T> cacheObserver); @Override void addGeneralObserver(final GeneralCacheObserver observer); @Override void removeGeneralObserver(final GeneralCacheObserver observer); @Override void clearObservers(); @Override void reset(); @Override String toString(); @Override void acquire(); @Override void release(); }
@Test public void addGeneralObserver() throws Exception { NativeCache cache = new NativeCache(); GeneralCacheObserver observer = new GeneralCacheObserver() { @Override public void newEntry(final Object o, final CacheObservable observable) { } @Override public void updatedEntry(final Object o, final CacheObservable observable) { } @Override public void deletedEntry(final Object o, final CacheObservable observable) { } }; cache.addGeneralObserver(observer); assertEquals(1, cache.countObservers()); } @Test public void countObserversOne() throws Exception { NativeCache cache = new NativeCache(); GeneralCacheObserver observer = new GeneralCacheObserver() { @Override public void newEntry(final Object o, final CacheObservable observable) { } @Override public void updatedEntry(final Object o, final CacheObservable observable) { } @Override public void deletedEntry(final Object o, final CacheObservable observable) { } }; cache.addGeneralObserver(observer); int count = cache.countObservers(); assertEquals(1, count); } @Test public void countObserversTwo() throws Exception { NativeCache cache = new NativeCache(); GeneralCacheObserver observer = new GeneralCacheObserver() { @Override public void newEntry(final Object o, final CacheObservable observable) { } @Override public void updatedEntry(final Object o, final CacheObservable observable) { } @Override public void deletedEntry(final Object o, final CacheObservable observable) { } }; GeneralCacheObserver observer2 = new GeneralCacheObserver() { @Override public void newEntry(final Object o, final CacheObservable observable) { } @Override public void updatedEntry(final Object o, final CacheObservable observable) { } @Override public void deletedEntry(final Object o, final CacheObservable observable) { } }; cache.addGeneralObserver(observer); cache.addGeneralObserver(observer2); int count = cache.countObservers(); assertEquals(2, count); }
NativeCache extends CacheObservable implements Cache { @Override public void removeGeneralObserver(final GeneralCacheObserver observer) { logging.debug("Removing Observer(" + observer + ") from " + toString()); NetCom2Utils.parameterNotNull(observer); deleteObserver(observer); } NativeCache(); @Override void update(final Object object); @Override void addNew(final Object object); @Override void addAndOverride(final Object object); @Override void remove(final Class clazz); @Override @SuppressWarnings("unchecked") Optional<T> get(final Class<T> clazz); @Override boolean isSet(final Class<?> clazz); @Override void addCacheObserver(final CacheObserver<T> cacheObserver); @Override void removeCacheObserver(final CacheObserver<T> cacheObserver); @Override void addGeneralObserver(final GeneralCacheObserver observer); @Override void removeGeneralObserver(final GeneralCacheObserver observer); @Override void clearObservers(); @Override void reset(); @Override String toString(); @Override void acquire(); @Override void release(); }
@Test public void removeGeneralObserver() throws Exception { NativeCache cache = new NativeCache(); GeneralCacheObserver observer = new GeneralCacheObserver() { @Override public void newEntry(final Object o, final CacheObservable observable) { } @Override public void updatedEntry(final Object o, final CacheObservable observable) { } @Override public void deletedEntry(final Object o, final CacheObservable observable) { } }; cache.addGeneralObserver(observer); cache.removeGeneralObserver(observer); assertEquals(0, cache.countObservers()); }
NativeCache extends CacheObservable implements Cache { @Override public void clearObservers() { logging.trace("Deleting all Observers currently registered .."); logging.trace("#Observers before: " + countObservers()); deleteObservers(); logging.trace("#Observers after: " + countObservers()); } NativeCache(); @Override void update(final Object object); @Override void addNew(final Object object); @Override void addAndOverride(final Object object); @Override void remove(final Class clazz); @Override @SuppressWarnings("unchecked") Optional<T> get(final Class<T> clazz); @Override boolean isSet(final Class<?> clazz); @Override void addCacheObserver(final CacheObserver<T> cacheObserver); @Override void removeCacheObserver(final CacheObserver<T> cacheObserver); @Override void addGeneralObserver(final GeneralCacheObserver observer); @Override void removeGeneralObserver(final GeneralCacheObserver observer); @Override void clearObservers(); @Override void reset(); @Override String toString(); @Override void acquire(); @Override void release(); }
@Test public void clearObserversNoObserver() throws Exception { NativeCache cache = new NativeCache(); cache.clearObservers(); assertEquals(0, cache.countObservers()); }
NativeCache extends CacheObservable implements Cache { @Override public void reset() { logging.debug("Resetting Cache!"); clearObservers(); logging.trace("Clearing all previously cached instances .."); internals.clear(); } NativeCache(); @Override void update(final Object object); @Override void addNew(final Object object); @Override void addAndOverride(final Object object); @Override void remove(final Class clazz); @Override @SuppressWarnings("unchecked") Optional<T> get(final Class<T> clazz); @Override boolean isSet(final Class<?> clazz); @Override void addCacheObserver(final CacheObserver<T> cacheObserver); @Override void removeCacheObserver(final CacheObserver<T> cacheObserver); @Override void addGeneralObserver(final GeneralCacheObserver observer); @Override void removeGeneralObserver(final GeneralCacheObserver observer); @Override void clearObservers(); @Override void reset(); @Override String toString(); @Override void acquire(); @Override void release(); }
@Test public void reset() throws Exception { NativeCache cache = new NativeCache(); cache.addAndOverride(new CacheElement()); GeneralCacheObserver observer = new GeneralCacheObserver() { @Override public void newEntry(final Object o, final CacheObservable observable) { } @Override public void updatedEntry(final Object o, final CacheObservable observable) { } @Override public void deletedEntry(final Object o, final CacheObservable observable) { } }; cache.addGeneralObserver(observer); cache.reset(); Optional<CacheElement> optional = cache.get(CacheElement.class); assertEquals(0, cache.countObservers()); assertFalse(optional.isPresent()); }
NativeSender implements Sender { @Override public void objectToServer(Object o) { clientValue.get() .send(o); } NativeSender(); @Override void objectToServer(Object o); @Override void objectToServer(Object o, Connection connection); @Override void objectToServer(Object o, Class connectionKey); @Override void registrationToServer(Class<T> clazz, CacheObserver<T> observer); @Override void registrationToServer(Class<T> clazz, CacheObserver<T> observer, Connection connection); @Override void registrationToServer(Class<T> clazz, CacheObserver<T> observer, Class connectionKey); @Override void unRegistrationToServer(Class<T> clazz); @Override void unRegistrationToServer(Class<T> clazz, Connection connection); @Override void unRegistrationToServer(Class<T> clazz, Class connectionKey); @Override void reset(); @Override synchronized void setup(ClientStart clientStart); @Override void close(); }
@Test public void objectToServer() throws Exception { NativeSender sender = new NativeSender(); sender.setup(clientStart); TestSendObject testSendObject = new TestSendObject(); sender.objectToServer(testSendObject); verify(client).send(eq(testSendObject)); }
NativeSender implements Sender { @Override public <T> void registrationToServer(Class<T> clazz, CacheObserver<T> observer) { synchronized (observerLimbo) { observerLimbo.put(clazz, observer); } objectToServer(new CacheRegistration(clazz)); } NativeSender(); @Override void objectToServer(Object o); @Override void objectToServer(Object o, Connection connection); @Override void objectToServer(Object o, Class connectionKey); @Override void registrationToServer(Class<T> clazz, CacheObserver<T> observer); @Override void registrationToServer(Class<T> clazz, CacheObserver<T> observer, Connection connection); @Override void registrationToServer(Class<T> clazz, CacheObserver<T> observer, Class connectionKey); @Override void unRegistrationToServer(Class<T> clazz); @Override void unRegistrationToServer(Class<T> clazz, Connection connection); @Override void unRegistrationToServer(Class<T> clazz, Class connectionKey); @Override void reset(); @Override synchronized void setup(ClientStart clientStart); @Override void close(); }
@Test public void registrationToServer() throws Exception { NativeSender sender = new NativeSender(); sender.setup(clientStart); TestCacheObserver<TestSendObject> observer = new TestCacheObserver<>(TestSendObject.class); sender.registrationToServer(TestSendObject.class, observer); verify(client).send(any(CacheRegistration.class)); }
RemoteAccessBlockRegistration { @APILevel void release(RemoteAccessCommunicationResponse response) { NetCom2Utils.parameterNotNull(response); synchronized (responseMap) { responseMap.put(response.getUuid(), response); } Semaphore semaphore = getSemaphore(response.getUuid()); if (semaphore == null) { return; } semaphore.release(); } RemoteAccessBlockRegistration(); }
@Test public void release() throws Exception { RemoteAccessBlockRegistration registration = new RemoteAccessBlockRegistration(); UUID id = UUID.randomUUID(); Semaphore semaphore = registration.await(new RemoteAccessCommunicationRequest("", Example.class, id, new Object[0])); assertEquals(0, semaphore.availablePermits()); registration.release(new RemoteAccessCommunicationResponse(id, null, null)); assertEquals(1, semaphore.availablePermits()); }
NativeSender implements Sender { @Override public <T> void unRegistrationToServer(Class<T> clazz) { objectToServer(new CacheUnRegistration(clazz)); } NativeSender(); @Override void objectToServer(Object o); @Override void objectToServer(Object o, Connection connection); @Override void objectToServer(Object o, Class connectionKey); @Override void registrationToServer(Class<T> clazz, CacheObserver<T> observer); @Override void registrationToServer(Class<T> clazz, CacheObserver<T> observer, Connection connection); @Override void registrationToServer(Class<T> clazz, CacheObserver<T> observer, Class connectionKey); @Override void unRegistrationToServer(Class<T> clazz); @Override void unRegistrationToServer(Class<T> clazz, Connection connection); @Override void unRegistrationToServer(Class<T> clazz, Class connectionKey); @Override void reset(); @Override synchronized void setup(ClientStart clientStart); @Override void close(); }
@Test public void unRegistrationToServer() throws Exception { NativeSender sender = new NativeSender(); sender.setup(clientStart); TestCacheObserver<TestSendObject> observer = new TestCacheObserver<>(TestSendObject.class); sender.registrationToServer(TestSendObject.class, observer); sender.unRegistrationToServer(TestSendObject.class); verify(client).send(any(CacheUnRegistration.class)); }
NativeSender implements Sender { @Override public void reset() { synchronized (observerLimbo) { observerLimbo.forEach((key, value) -> cache.removeCacheObserver(value)); observerLimbo.clear(); } } NativeSender(); @Override void objectToServer(Object o); @Override void objectToServer(Object o, Connection connection); @Override void objectToServer(Object o, Class connectionKey); @Override void registrationToServer(Class<T> clazz, CacheObserver<T> observer); @Override void registrationToServer(Class<T> clazz, CacheObserver<T> observer, Connection connection); @Override void registrationToServer(Class<T> clazz, CacheObserver<T> observer, Class connectionKey); @Override void unRegistrationToServer(Class<T> clazz); @Override void unRegistrationToServer(Class<T> clazz, Connection connection); @Override void unRegistrationToServer(Class<T> clazz, Class connectionKey); @Override void reset(); @Override synchronized void setup(ClientStart clientStart); @Override void close(); }
@Test public void reset() throws Exception { NativeSender sender = new NativeSender(); sender.setup(clientStart); TestCacheObserver<TestSendObject> observer = new TestCacheObserver<>(TestSendObject.class); sender.registrationToServer(TestSendObject.class, observer); sender.reset(); }
NativeClientStart implements ClientStart { @Override public synchronized void launch() throws StartFailedException { if (running.get()) { loggingValue.get().warn("ClientStart is already started! Cannot start an already started NetworkInterface!"); } SocketAddress socketAddress = addressValue.get(); if (addressValue.isEmpty()) { throw new StartFailedException("Could not find requested SocketAddress to start this ClientStart!"); } ClientDefaultCommunication.applyTo(this); clientCore.establishConnection(socketAddress, client); running.set(true); loggingValue.get().info("ClientStart started at " + socketAddress); } NativeClientStart(SocketAddress address, ClientCore clientCore); @Override Awaiting newConnection(Class<?> identifier); @Override void addFallBackSerialization(SerializationAdapter serializationAdapter); @Override void addFallBackDeSerialization(DeSerializationAdapter deSerializationAdapter); @Override void setMainSerializationAdapter(SerializationAdapter mainSerializationAdapter); @Override void setMainDeSerializationAdapter(DeSerializationAdapter mainDeSerializationAdapter); @Override void addDisconnectedHandler(ClientDisconnectedHandler clientDisconnectedHandler); @Override void addDecryptionAdapter(DecryptionAdapter decryptionAdapter); @Override void addEncryptionAdapter(EncryptionAdapter encryptionAdapter); @Override void clearCache(); @Override Cache cache(); @Override CommunicationRegistration getCommunicationRegistration(); @Override synchronized void launch(); @Override void startBlockerThread(); @Override void blockOnCurrentThread(); @Override void setLogging(Logging logging); @Override void softStop(); @Override boolean running(); @Override String toString(); }
@Test public void launch() throws Exception { NativeClientStart clientStart = new NativeClientStart(new InetSocketAddress(ADDRESS, PORT), mockedClientCore); clientStart.launch(); assertTrue(clientStart.running()); verify(mockedClientCore).establishConnection(socketAddress, clientStart.getClient()); } @Test(expected = IllegalStateException.class) public void setSocketFactory() throws Exception { ClientStart clientStart = new NativeClientStart(socketAddress, mockedClientCore); doThrow(IllegalStateException.class).when(mockedClientCore).establishConnection(any(), any()); clientStart.launch(); fail(); }
NativeClientStart implements ClientStart { @Override public Cache cache() { return cache; } NativeClientStart(SocketAddress address, ClientCore clientCore); @Override Awaiting newConnection(Class<?> identifier); @Override void addFallBackSerialization(SerializationAdapter serializationAdapter); @Override void addFallBackDeSerialization(DeSerializationAdapter deSerializationAdapter); @Override void setMainSerializationAdapter(SerializationAdapter mainSerializationAdapter); @Override void setMainDeSerializationAdapter(DeSerializationAdapter mainDeSerializationAdapter); @Override void addDisconnectedHandler(ClientDisconnectedHandler clientDisconnectedHandler); @Override void addDecryptionAdapter(DecryptionAdapter decryptionAdapter); @Override void addEncryptionAdapter(EncryptionAdapter encryptionAdapter); @Override void clearCache(); @Override Cache cache(); @Override CommunicationRegistration getCommunicationRegistration(); @Override synchronized void launch(); @Override void startBlockerThread(); @Override void blockOnCurrentThread(); @Override void setLogging(Logging logging); @Override void softStop(); @Override boolean running(); @Override String toString(); }
@Test public void cache() throws Exception { ClientStart clientStart = new NativeClientStart(socketAddress, mockedClientCore); final AtomicBoolean success = new AtomicBoolean(false); CacheObserver<TestSendObject> observer = new TestObserver(success); Cache cache = clientStart.cache(); cache.addCacheObserver(observer); assertEquals(cache, clientStart.cache()); assertFalse(success.get()); clientStart.cache().addAndOverride(new TestSendObject()); assertTrue(success.get()); }
NativeClientStart implements ClientStart { @Override public Awaiting newConnection(Class<?> identifier) throws ConnectionEstablishmentFailedException { try { clientCore.establishConnection(addressValue.get(), client, identifier); } catch (StartFailedException e) { throw new ConnectionEstablishmentFailedException(e); } return client.getConnection(identifier) .orElseThrow(() -> new ConnectionEstablishmentFailedException("Connection has not been set properly! Please submit this to github!")) .connected(); } NativeClientStart(SocketAddress address, ClientCore clientCore); @Override Awaiting newConnection(Class<?> identifier); @Override void addFallBackSerialization(SerializationAdapter serializationAdapter); @Override void addFallBackDeSerialization(DeSerializationAdapter deSerializationAdapter); @Override void setMainSerializationAdapter(SerializationAdapter mainSerializationAdapter); @Override void setMainDeSerializationAdapter(DeSerializationAdapter mainDeSerializationAdapter); @Override void addDisconnectedHandler(ClientDisconnectedHandler clientDisconnectedHandler); @Override void addDecryptionAdapter(DecryptionAdapter decryptionAdapter); @Override void addEncryptionAdapter(EncryptionAdapter encryptionAdapter); @Override void clearCache(); @Override Cache cache(); @Override CommunicationRegistration getCommunicationRegistration(); @Override synchronized void launch(); @Override void startBlockerThread(); @Override void blockOnCurrentThread(); @Override void setLogging(Logging logging); @Override void softStop(); @Override boolean running(); @Override String toString(); }
@Test public void newConnection() throws Exception { NativeClientStart clientStart = new NativeClientStart(socketAddress, mockedClientCore); Connection mockedConnection = mock(Connection.class); when(mockedConnection.getIdentifier()).thenReturn(Optional.of(TestSendObject.class)); doAnswer((i) -> { clientStart.getClient().addConnection(mockedConnection); return null; }).when(mockedClientCore).establishConnection(socketAddress, clientStart.getClient(), TestSendObject.class); clientStart.launch(); clientStart.newConnection(TestSendObject.class); Optional<Connection> connection = clientStart.getClient().getConnection(TestSendObject.class); verify(mockedClientCore).establishConnection(socketAddress, clientStart.getClient()); verify(mockedClientCore).establishConnection(socketAddress, clientStart.getClient(), TestSendObject.class); assertTrue(connection.isPresent()); assertEquals(mockedConnection, connection.get()); } @Test(expected = ConnectionEstablishmentFailedException.class) public void newConnectionNeg() throws Exception { ClientStart clientStart = new NativeClientStart(socketAddress, mockedClientCore); clientStart.newConnection(TestSendObject.class); fail(); }
NativeClientStart implements ClientStart { @Override public void addFallBackSerialization(SerializationAdapter serializationAdapter) { client.objectHandler().addFallbackSerialization(serializationAdapter); } NativeClientStart(SocketAddress address, ClientCore clientCore); @Override Awaiting newConnection(Class<?> identifier); @Override void addFallBackSerialization(SerializationAdapter serializationAdapter); @Override void addFallBackDeSerialization(DeSerializationAdapter deSerializationAdapter); @Override void setMainSerializationAdapter(SerializationAdapter mainSerializationAdapter); @Override void setMainDeSerializationAdapter(DeSerializationAdapter mainDeSerializationAdapter); @Override void addDisconnectedHandler(ClientDisconnectedHandler clientDisconnectedHandler); @Override void addDecryptionAdapter(DecryptionAdapter decryptionAdapter); @Override void addEncryptionAdapter(EncryptionAdapter encryptionAdapter); @Override void clearCache(); @Override Cache cache(); @Override CommunicationRegistration getCommunicationRegistration(); @Override synchronized void launch(); @Override void startBlockerThread(); @Override void blockOnCurrentThread(); @Override void setLogging(Logging logging); @Override void softStop(); @Override boolean running(); @Override String toString(); }
@Test public void addFallBackSerialization() throws Exception { NativeClientStart clientStart = new NativeClientStart(socketAddress, mockedClientCore); SerializationAdapter adapter = Object::toString; clientStart.addFallBackSerialization(adapter); }
NativeClientStart implements ClientStart { @Override public void addFallBackDeSerialization(DeSerializationAdapter deSerializationAdapter) { client.objectHandler().addFallbackDeserialization(deSerializationAdapter); } NativeClientStart(SocketAddress address, ClientCore clientCore); @Override Awaiting newConnection(Class<?> identifier); @Override void addFallBackSerialization(SerializationAdapter serializationAdapter); @Override void addFallBackDeSerialization(DeSerializationAdapter deSerializationAdapter); @Override void setMainSerializationAdapter(SerializationAdapter mainSerializationAdapter); @Override void setMainDeSerializationAdapter(DeSerializationAdapter mainDeSerializationAdapter); @Override void addDisconnectedHandler(ClientDisconnectedHandler clientDisconnectedHandler); @Override void addDecryptionAdapter(DecryptionAdapter decryptionAdapter); @Override void addEncryptionAdapter(EncryptionAdapter encryptionAdapter); @Override void clearCache(); @Override Cache cache(); @Override CommunicationRegistration getCommunicationRegistration(); @Override synchronized void launch(); @Override void startBlockerThread(); @Override void blockOnCurrentThread(); @Override void setLogging(Logging logging); @Override void softStop(); @Override boolean running(); @Override String toString(); }
@Test public void addFallBackDeSerialization() throws Exception { NativeClientStart clientStart = new NativeClientStart(socketAddress, mockedClientCore); DeSerializationAdapter adapter = o -> o; clientStart.addFallBackDeSerialization(adapter); }
NativeClientStart implements ClientStart { @Override public void setMainSerializationAdapter(SerializationAdapter mainSerializationAdapter) { client.objectHandler().setMainSerialization(mainSerializationAdapter); } NativeClientStart(SocketAddress address, ClientCore clientCore); @Override Awaiting newConnection(Class<?> identifier); @Override void addFallBackSerialization(SerializationAdapter serializationAdapter); @Override void addFallBackDeSerialization(DeSerializationAdapter deSerializationAdapter); @Override void setMainSerializationAdapter(SerializationAdapter mainSerializationAdapter); @Override void setMainDeSerializationAdapter(DeSerializationAdapter mainDeSerializationAdapter); @Override void addDisconnectedHandler(ClientDisconnectedHandler clientDisconnectedHandler); @Override void addDecryptionAdapter(DecryptionAdapter decryptionAdapter); @Override void addEncryptionAdapter(EncryptionAdapter encryptionAdapter); @Override void clearCache(); @Override Cache cache(); @Override CommunicationRegistration getCommunicationRegistration(); @Override synchronized void launch(); @Override void startBlockerThread(); @Override void blockOnCurrentThread(); @Override void setLogging(Logging logging); @Override void softStop(); @Override boolean running(); @Override String toString(); }
@Test public void setMainSerializationAdapter() throws Exception { NativeClientStart clientStart = new NativeClientStart(socketAddress, mockedClientCore); SerializationAdapter adapter = Object::toString; clientStart.setMainSerializationAdapter(adapter); }
RemoteAccessBlockRegistration { @APILevel RemoteAccessCommunicationResponse getResponse(UUID uuid) { NetCom2Utils.parameterNotNull(uuid); synchronized (responseMap) { return responseMap.get(uuid); } } RemoteAccessBlockRegistration(); }
@Test public void getResponse() throws Exception { RemoteAccessBlockRegistration registration = new RemoteAccessBlockRegistration(); UUID id = UUID.randomUUID(); RemoteAccessCommunicationResponse response = new RemoteAccessCommunicationResponse(id, null, null); Semaphore semaphore = registration.await(new RemoteAccessCommunicationRequest("", Example.class, id, new Object[0])); registration.release(response); RemoteAccessCommunicationResponse foundResponse = registration.getResponse(id); assertEquals(1, semaphore.availablePermits()); assertEquals(1, registration.countSemaphores()); assertEquals(1, registration.countResponses()); assertEquals(response, foundResponse); }
NativeClientStart implements ClientStart { @Override public void setMainDeSerializationAdapter(DeSerializationAdapter mainDeSerializationAdapter) { client.objectHandler().setMainDeserialization(mainDeSerializationAdapter); } NativeClientStart(SocketAddress address, ClientCore clientCore); @Override Awaiting newConnection(Class<?> identifier); @Override void addFallBackSerialization(SerializationAdapter serializationAdapter); @Override void addFallBackDeSerialization(DeSerializationAdapter deSerializationAdapter); @Override void setMainSerializationAdapter(SerializationAdapter mainSerializationAdapter); @Override void setMainDeSerializationAdapter(DeSerializationAdapter mainDeSerializationAdapter); @Override void addDisconnectedHandler(ClientDisconnectedHandler clientDisconnectedHandler); @Override void addDecryptionAdapter(DecryptionAdapter decryptionAdapter); @Override void addEncryptionAdapter(EncryptionAdapter encryptionAdapter); @Override void clearCache(); @Override Cache cache(); @Override CommunicationRegistration getCommunicationRegistration(); @Override synchronized void launch(); @Override void startBlockerThread(); @Override void blockOnCurrentThread(); @Override void setLogging(Logging logging); @Override void softStop(); @Override boolean running(); @Override String toString(); }
@Test public void setMainDeSerializationAdapter() throws Exception { NativeClientStart clientStart = new NativeClientStart(socketAddress, mockedClientCore); DeSerializationAdapter adapter = o -> o; clientStart.setMainDeSerializationAdapter(adapter); }
NativeClientStart implements ClientStart { @Override public void addDisconnectedHandler(ClientDisconnectedHandler clientDisconnectedHandler) { client.addDisconnectedHandler(clientDisconnectedHandler); } NativeClientStart(SocketAddress address, ClientCore clientCore); @Override Awaiting newConnection(Class<?> identifier); @Override void addFallBackSerialization(SerializationAdapter serializationAdapter); @Override void addFallBackDeSerialization(DeSerializationAdapter deSerializationAdapter); @Override void setMainSerializationAdapter(SerializationAdapter mainSerializationAdapter); @Override void setMainDeSerializationAdapter(DeSerializationAdapter mainDeSerializationAdapter); @Override void addDisconnectedHandler(ClientDisconnectedHandler clientDisconnectedHandler); @Override void addDecryptionAdapter(DecryptionAdapter decryptionAdapter); @Override void addEncryptionAdapter(EncryptionAdapter encryptionAdapter); @Override void clearCache(); @Override Cache cache(); @Override CommunicationRegistration getCommunicationRegistration(); @Override synchronized void launch(); @Override void startBlockerThread(); @Override void blockOnCurrentThread(); @Override void setLogging(Logging logging); @Override void softStop(); @Override boolean running(); @Override String toString(); }
@Test public void addDisconnectedHandler() throws Exception { NativeClientStart clientStart = new NativeClientStart(socketAddress, mockedClientCore); ClientDisconnectedHandler clientDisconnectedHandler = client -> { }; clientStart.addDisconnectedHandler(clientDisconnectedHandler); }
NativeClientStart implements ClientStart { @Override public CommunicationRegistration getCommunicationRegistration() { return communicationRegistration; } NativeClientStart(SocketAddress address, ClientCore clientCore); @Override Awaiting newConnection(Class<?> identifier); @Override void addFallBackSerialization(SerializationAdapter serializationAdapter); @Override void addFallBackDeSerialization(DeSerializationAdapter deSerializationAdapter); @Override void setMainSerializationAdapter(SerializationAdapter mainSerializationAdapter); @Override void setMainDeSerializationAdapter(DeSerializationAdapter mainDeSerializationAdapter); @Override void addDisconnectedHandler(ClientDisconnectedHandler clientDisconnectedHandler); @Override void addDecryptionAdapter(DecryptionAdapter decryptionAdapter); @Override void addEncryptionAdapter(EncryptionAdapter encryptionAdapter); @Override void clearCache(); @Override Cache cache(); @Override CommunicationRegistration getCommunicationRegistration(); @Override synchronized void launch(); @Override void startBlockerThread(); @Override void blockOnCurrentThread(); @Override void setLogging(Logging logging); @Override void softStop(); @Override boolean running(); @Override String toString(); }
@Test public void getCommunicationRegistration() throws Exception { ClientStart clientStart = new NativeClientStart(socketAddress, mockedClientCore); CommunicationRegistration communicationRegistration = clientStart.getCommunicationRegistration(); assertNotNull(communicationRegistration); }
NativeClientStart implements ClientStart { @Override public void clearCache() { cache.reset(); } NativeClientStart(SocketAddress address, ClientCore clientCore); @Override Awaiting newConnection(Class<?> identifier); @Override void addFallBackSerialization(SerializationAdapter serializationAdapter); @Override void addFallBackDeSerialization(DeSerializationAdapter deSerializationAdapter); @Override void setMainSerializationAdapter(SerializationAdapter mainSerializationAdapter); @Override void setMainDeSerializationAdapter(DeSerializationAdapter mainDeSerializationAdapter); @Override void addDisconnectedHandler(ClientDisconnectedHandler clientDisconnectedHandler); @Override void addDecryptionAdapter(DecryptionAdapter decryptionAdapter); @Override void addEncryptionAdapter(EncryptionAdapter encryptionAdapter); @Override void clearCache(); @Override Cache cache(); @Override CommunicationRegistration getCommunicationRegistration(); @Override synchronized void launch(); @Override void startBlockerThread(); @Override void blockOnCurrentThread(); @Override void setLogging(Logging logging); @Override void softStop(); @Override boolean running(); @Override String toString(); }
@Test public void clearCache() throws Exception { ClientStart clientStart = new NativeClientStart(socketAddress, mockedClientCore); final AtomicBoolean success = new AtomicBoolean(false); CacheObserver<TestSendObject> observer = new TestObserver(success); clientStart.cache().addCacheObserver(observer); Cache cache = clientStart.cache(); clientStart.clearCache(); assertEquals(cache, clientStart.cache()); assertEquals(0, cache.countObservers()); }
NativeServerStart implements ServerStart { @Override public final synchronized void launch() throws StartFailedException { if (running.get()) { loggingValue.get().warn("ServerStart is already started! Cannot start an already started NetworkInterface!"); } final Logging logging = loggingValue.get(); logging.debug("Launching the ServerStart"); logging.trace("Registering internal Requests .."); ServerDefaultCommunication.applyTo(this); logging.trace("Requesting connectorCore value .."); final InetSocketAddress address = addressValue.get(); logging.trace("Requesting connection establishment for " + address); connectorCoreValue.get().establishConnection(address); logging.trace("Updating running flag .."); running.set(true); logging.info("ServerStart launched at " + getPort()); } NativeServerStart(final InetSocketAddress address); @Override final void addClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final void removeClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final ClientFactory getClientFactory(); @Override final synchronized void launch(); @Override final void acceptNextClient(); @Override final void acceptAllNextClients(); @Override final void disconnect(); @Override final ClientList clientList(); @Override final Awaiting createNewConnection(final Session session, final Class key); @Override final Cache cache(); @Override final CommunicationRegistration getCommunicationRegistration(); @Override final void setLogging(final Logging logging); @Override final void softStop(); @Override final boolean running(); @Override final int getPort(); @Override final void setPort(final int to); @Override final void setConnectorCore(final ConnectorCore connectorCore); }
@Test public void launch() throws Exception { serverStart.launch(); assertTrue(serverStart.running()); verify(connectorCore).establishConnection(any()); verify(connectorCore, never()).disconnect(); } @Test(expected = StartFailedException.class) public void launchFail() throws Exception { doThrow(StartFailedException.class).when(connectorCore).establishConnection(socketAddress); serverStart.launch(); fail(); }
NativeServerStart implements ServerStart { @Override public final void acceptAllNextClients() throws ClientConnectionFailedException { final Logging logging = loggingValue.get(); final Thread thread = Thread.currentThread(); logging.debug("Accepting all connecting Clients on " + thread + ". This Thread will be blocked."); while (running()) { logging.trace("Requesting acceptance of next Client."); acceptNextClient(); logging.trace("Client acceptance finished."); } logging.trace("Stop detected. Releasing current Thread." + thread); } NativeServerStart(final InetSocketAddress address); @Override final void addClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final void removeClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final ClientFactory getClientFactory(); @Override final synchronized void launch(); @Override final void acceptNextClient(); @Override final void acceptAllNextClients(); @Override final void disconnect(); @Override final ClientList clientList(); @Override final Awaiting createNewConnection(final Session session, final Class key); @Override final Cache cache(); @Override final CommunicationRegistration getCommunicationRegistration(); @Override final void setLogging(final Logging logging); @Override final void softStop(); @Override final boolean running(); @Override final int getPort(); @Override final void setPort(final int to); @Override final void setConnectorCore(final ConnectorCore connectorCore); }
@Test(expected = ClientConnectionFailedException.class) public void acceptAllNextClients() throws Exception { doThrow(ClientConnectionFailedException.class).when(connectorCore).handleNext(); serverStart.launch(); serverStart.acceptAllNextClients(); fail(); } @Test public void acceptAllNextClientsNotLaunched() throws Exception { serverStart.acceptAllNextClients(); verify(logging, atLeastOnce()).trace(any(String.class)); }
NativeServerStart implements ServerStart { @Override public final void setPort(final int to) { if (running.get()) { return; } synchronized (addressValue) { final InetSocketAddress current = addressValue.get(); addressValue.set(new InetSocketAddress(current.getAddress(), to)); } } NativeServerStart(final InetSocketAddress address); @Override final void addClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final void removeClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final ClientFactory getClientFactory(); @Override final synchronized void launch(); @Override final void acceptNextClient(); @Override final void acceptAllNextClients(); @Override final void disconnect(); @Override final ClientList clientList(); @Override final Awaiting createNewConnection(final Session session, final Class key); @Override final Cache cache(); @Override final CommunicationRegistration getCommunicationRegistration(); @Override final void setLogging(final Logging logging); @Override final void softStop(); @Override final boolean running(); @Override final int getPort(); @Override final void setPort(final int to); @Override final void setConnectorCore(final ConnectorCore connectorCore); }
@Test public void setPort() throws Exception { serverStart.setPort(1); assertEquals(1, serverStart.getPort()); }
NativeServerStart implements ServerStart { @Override public final void acceptNextClient() throws ClientConnectionFailedException { final Logging logging = loggingValue.get(); logging.debug("Accepting next client."); logging.trace("Checking ConnectorCore value .."); logging.trace("Requesting next Client handling at ConnectorCore .."); connectorCoreValue.get().handleNext(); logging.debug("New Client handled"); } NativeServerStart(final InetSocketAddress address); @Override final void addClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final void removeClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final ClientFactory getClientFactory(); @Override final synchronized void launch(); @Override final void acceptNextClient(); @Override final void acceptAllNextClients(); @Override final void disconnect(); @Override final ClientList clientList(); @Override final Awaiting createNewConnection(final Session session, final Class key); @Override final Cache cache(); @Override final CommunicationRegistration getCommunicationRegistration(); @Override final void setLogging(final Logging logging); @Override final void softStop(); @Override final boolean running(); @Override final int getPort(); @Override final void setPort(final int to); @Override final void setConnectorCore(final ConnectorCore connectorCore); }
@Test(expected = ClientConnectionFailedException.class) public void acceptNextClient() throws Exception { doThrow(ClientConnectionFailedException.class).when(connectorCore).handleNext(); serverStart.launch(); serverStart.acceptNextClient(); fail(); } @Test(expected = ClientConnectionFailedException.class) public void acceptNextClientNotLaunched() throws Exception { doThrow(ClientConnectionFailedException.class).when(connectorCore).handleNext(); serverStart.acceptNextClient(); fail(); }
NativeServerStart implements ServerStart { @Override public final Cache cache() { return cache; } NativeServerStart(final InetSocketAddress address); @Override final void addClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final void removeClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final ClientFactory getClientFactory(); @Override final synchronized void launch(); @Override final void acceptNextClient(); @Override final void acceptAllNextClients(); @Override final void disconnect(); @Override final ClientList clientList(); @Override final Awaiting createNewConnection(final Session session, final Class key); @Override final Cache cache(); @Override final CommunicationRegistration getCommunicationRegistration(); @Override final void setLogging(final Logging logging); @Override final void softStop(); @Override final boolean running(); @Override final int getPort(); @Override final void setPort(final int to); @Override final void setConnectorCore(final ConnectorCore connectorCore); }
@Test public void cache() throws Exception { Cache cache = serverStart.cache(); assertNotNull(cache); }
NativeServerStart implements ServerStart { @Override public final void disconnect() { softStop(); connectorCoreValue.get().disconnect(); } NativeServerStart(final InetSocketAddress address); @Override final void addClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final void removeClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final ClientFactory getClientFactory(); @Override final synchronized void launch(); @Override final void acceptNextClient(); @Override final void acceptAllNextClients(); @Override final void disconnect(); @Override final ClientList clientList(); @Override final Awaiting createNewConnection(final Session session, final Class key); @Override final Cache cache(); @Override final CommunicationRegistration getCommunicationRegistration(); @Override final void setLogging(final Logging logging); @Override final void softStop(); @Override final boolean running(); @Override final int getPort(); @Override final void setPort(final int to); @Override final void setConnectorCore(final ConnectorCore connectorCore); }
@Test public void disconnect() throws Exception { serverStart.launch(); serverStart.disconnect(); assertFalse(serverStart.running()); }
NativeServerStart implements ServerStart { @Override public final ClientList clientList() { return clientList; } NativeServerStart(final InetSocketAddress address); @Override final void addClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final void removeClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final ClientFactory getClientFactory(); @Override final synchronized void launch(); @Override final void acceptNextClient(); @Override final void acceptAllNextClients(); @Override final void disconnect(); @Override final ClientList clientList(); @Override final Awaiting createNewConnection(final Session session, final Class key); @Override final Cache cache(); @Override final CommunicationRegistration getCommunicationRegistration(); @Override final void setLogging(final Logging logging); @Override final void softStop(); @Override final boolean running(); @Override final int getPort(); @Override final void setPort(final int to); @Override final void setConnectorCore(final ConnectorCore connectorCore); }
@Test public void clientList() throws Exception { serverStart.launch(); ClientList clients = serverStart.clientList(); assertNotNull(clients); } @Test public void clientListNotLaunched() throws Exception { ClientList clients = serverStart.clientList(); assertNotNull(clients); }
NativeServerStart implements ServerStart { @Override public final CommunicationRegistration getCommunicationRegistration() { return communicationRegistration; } NativeServerStart(final InetSocketAddress address); @Override final void addClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final void removeClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final ClientFactory getClientFactory(); @Override final synchronized void launch(); @Override final void acceptNextClient(); @Override final void acceptAllNextClients(); @Override final void disconnect(); @Override final ClientList clientList(); @Override final Awaiting createNewConnection(final Session session, final Class key); @Override final Cache cache(); @Override final CommunicationRegistration getCommunicationRegistration(); @Override final void setLogging(final Logging logging); @Override final void softStop(); @Override final boolean running(); @Override final int getPort(); @Override final void setPort(final int to); @Override final void setConnectorCore(final ConnectorCore connectorCore); }
@Test public void getCommunicationRegistration() throws Exception { serverStart.launch(); CommunicationRegistration registration = serverStart.getCommunicationRegistration(); assertNotNull(registration); } @Test public void getCommunicationRegistrationNotRunning() throws Exception { CommunicationRegistration registration = serverStart.getCommunicationRegistration(); assertNotNull(registration); }
NativeServerStart implements ServerStart { @Override public final void softStop() { running.set(false); } NativeServerStart(final InetSocketAddress address); @Override final void addClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final void removeClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final ClientFactory getClientFactory(); @Override final synchronized void launch(); @Override final void acceptNextClient(); @Override final void acceptAllNextClients(); @Override final void disconnect(); @Override final ClientList clientList(); @Override final Awaiting createNewConnection(final Session session, final Class key); @Override final Cache cache(); @Override final CommunicationRegistration getCommunicationRegistration(); @Override final void setLogging(final Logging logging); @Override final void softStop(); @Override final boolean running(); @Override final int getPort(); @Override final void setPort(final int to); @Override final void setConnectorCore(final ConnectorCore connectorCore); }
@Test public void softStop() throws Exception { serverStart.launch(); serverStart.softStop(); assertFalse(serverStart.running()); }
NativeServerStart implements ServerStart { @Override public final boolean running() { return running.get(); } NativeServerStart(final InetSocketAddress address); @Override final void addClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final void removeClientConnectedHandler(final ClientConnectedHandler clientConnectedHandler); @Override final ClientFactory getClientFactory(); @Override final synchronized void launch(); @Override final void acceptNextClient(); @Override final void acceptAllNextClients(); @Override final void disconnect(); @Override final ClientList clientList(); @Override final Awaiting createNewConnection(final Session session, final Class key); @Override final Cache cache(); @Override final CommunicationRegistration getCommunicationRegistration(); @Override final void setLogging(final Logging logging); @Override final void softStop(); @Override final boolean running(); @Override final int getPort(); @Override final void setPort(final int to); @Override final void setConnectorCore(final ConnectorCore connectorCore); }
@Test public void running() throws Exception { serverStart.launch(); boolean running = serverStart.running(); assertTrue(running); } @Test public void runningNotLaunched() throws Exception { boolean running = serverStart.running(); assertFalse(running); }
PipedPromise extends DeferredObject<D_OUT, F_OUT, P_OUT> implements Promise<D_OUT, F_OUT, P_OUT> { protected Promise<? extends D_OUT, ? extends F_OUT, ? extends P_OUT> pipe( Promise<? extends D_OUT, ? extends F_OUT, ? extends P_OUT> promise) { promise.done(new DoneCallback<D_OUT>() { @Override public void onDone(D_OUT result) { PipedPromise.this.resolve(result); } }).fail(new FailCallback<F_OUT>() { @Override public void onFail(F_OUT result) { PipedPromise.this.reject(result); } }).progress(new ProgressCallback<P_OUT>() { @Override public void onProgress(P_OUT progress) { PipedPromise.this.notify(progress); } }); return promise; } PipedPromise(final Promise<D, F, P> promise, final DonePipe<? super D, ? extends D_OUT, ? extends F_OUT, ? extends P_OUT> doneFilter, final FailPipe<? super F, ? extends D_OUT, ? extends F_OUT, ? extends P_OUT> failFilter, final ProgressPipe<? super P, ? extends D_OUT, ? extends F_OUT, ? extends P_OUT> progressFilter); PipedPromise(final Promise<D, F, P_OUT> promise, final AlwaysPipe<? super D, ? super F, ? extends D_OUT, ? extends F_OUT, ? extends P_OUT> alwaysFilter); }
@Test public void testDoneRewirePipe() { final ValueHolder<Integer> preRewireValue = new ValueHolder<Integer>(); final ValueHolder<Integer> postRewireValue = new ValueHolder<Integer>(); Callable<Integer> task = new Callable<Integer>() { public Integer call() { return 100; } }; deferredManager.when(task).pipe(new DonePipe<Integer, Integer, Throwable, Void>() { @Override public Promise<Integer, Throwable, Void> pipeDone(Integer result) { preRewireValue.set(result); return new DeferredObject<Integer, Throwable, Void>().resolve(1000); } }).done(new DoneCallback<Integer>() { @Override public void onDone(Integer value) { postRewireValue.set(value); } }); waitForCompletion(); preRewireValue.assertEquals(100); postRewireValue.assertEquals(1000); } @Test public void testFailRewirePipe() { final ValueHolder<String> preRewireValue = new ValueHolder<String>(); final ValueHolder<String> postRewireValue = new ValueHolder<String>(); Callable<Integer> task = new Callable<Integer>() { public Integer call() { throw new RuntimeException("oops"); } }; deferredManager.when(task).pipe(null, new FailPipe<Throwable, Integer, String, Void>() { @Override public Promise<Integer, String, Void> pipeFail(Throwable result) { preRewireValue.set(result.getMessage()); return new DeferredObject<Integer, String, Void>().reject("ouch"); } }).fail(new FailCallback<String>() { @Override public void onFail(String result) { postRewireValue.set(result); } }); waitForCompletion(); preRewireValue.assertEquals("oops"); postRewireValue.assertEquals("ouch"); } @Test public void testNullDoneRewirePipe() { final ValueHolder<Boolean> failed = new ValueHolder<Boolean>(false); final ValueHolder<Integer> postRewireValue = new ValueHolder<Integer>(); Callable<Integer> task = new Callable<Integer>() { public Integer call() { return 100; } }; deferredManager.when(task).pipe(null, new FailPipe<Throwable, Integer, String, Void>() { @Override public Promise<Integer, String, Void> pipeFail(Throwable result) { return new DeferredObject<Integer, String, Void>().reject("ouch"); } }).done(new DoneCallback<Integer>() { @Override public void onDone(Integer result) { postRewireValue.set(result); } }).fail(new FailCallback<String>() { @Override public void onFail(String result) { failed.set(true); } }); waitForCompletion(); failed.assertEquals(false); postRewireValue.assertEquals(100); } @Test public void testDoneRewireToFail() { final ValueHolder<Integer> preRewireValue = new ValueHolder<Integer>(); final ValueHolder<Integer> postRewireValue = new ValueHolder<Integer>(); final ValueHolder<String> failed = new ValueHolder<String>(); deferredManager.when(new Callable<Integer>() { public Integer call() { return 10; } }).pipe(new DonePipe<Integer, Integer, Throwable, Void>() { @Override public Promise<Integer, Throwable, Void> pipeDone(Integer result) { preRewireValue.set(result); if (result < 100) { return new DeferredObject<Integer, Throwable, Void>().reject(new Exception("less than 100")); } else { return new DeferredObject<Integer, Throwable, Void>().resolve(result); } } }).done(new DoneCallback<Integer>() { @Override public void onDone(Integer result) { postRewireValue.set(result); } }).fail(new FailCallback<Throwable>() { @Override public void onFail(Throwable result) { failed.set(result.getMessage()); } }); waitForCompletion(); preRewireValue.assertEquals(10); postRewireValue.assertEquals(null); failed.assertEquals("less than 100"); }
Bbb { public int plus(int a, int b) { int c = a + b; return 10000 + c; } int plus(int a, int b); }
@Test public void testPlus01() { Assert.assertEquals(10003, bbb.plus(1, 2)); }
Aaa { public List<String> toList(String... strs) { List<String> list = new ArrayList<>(strs.length); for (String str : strs) { list.add(str); } return list; } int add(int a, int b); String join(String... strs); List<String> toList(String... strs); }
@Test public void testToList01() { Aaa aaa = new Aaa(); List<String> list = aaa.toList("aa", "bb"); Assert.assertEquals("aa", list.get(0)); Assert.assertEquals("bb", list.get(1)); Assert.assertEquals(2, list.size()); }
PinyinAbbrTokenizer extends Tokenizer { @Override public void close() throws IOException { synonymFilter.close(); } PinyinAbbrTokenizer(Reader input); static boolean isChineseChar(char c); static boolean containsChineseChar(String str); @Override final boolean incrementToken(); @Override void close(); @Override void reset(); }
@Test public void test1() throws Exception { StringReader input = new StringReader("abc湖南省123"); PinyinAbbrTokenizer ts = new PinyinAbbrTokenizer(input); print(ts); ts.close(); }
Item implements Group, SpanSizeProvider { @Override public int getPosition(Item item) { return this == item ? 0 : -1; } Item(); protected Item(long id); @CallSuper void bind(ViewHolder<T> holder, int position, List<Object> payloads, OnItemClickListener onItemClickListener); @CallSuper void unbind(ViewHolder<T> holder); boolean isRecyclable(); @Override int getSpanSize(int spanCount, int position); int getSwipeDirs(); int getDragDirs(); abstract @LayoutRes int getLayout(); abstract void bind(T viewBinding, int position); void bind(T viewBinding, int position, List<Object> payloads); @Override int getItemCount(); @Override Item getItem(int position); @Override void setGroupDataObserver(GroupDataObserver groupDataObserver); @Override int getPosition(Item item); boolean isClickable(); void notifyChanged(); void notifyChanged(Object payload); Map<String, Object> getExtras(); long getId(); }
@Test public void selfPositionIs0() throws Exception { Item item = new DummyItem(); Assert.assertEquals(0, item.getPosition(item)); } @Test public void positionIsNegative1IfItemIsNotSelf() throws Exception { Item item = new DummyItem(); Item differentItem = new DummyItem(); Assert.assertEquals(-1, item.getPosition(differentItem)); }
Section extends NestedGroup { public void setFooter(@NonNull Group footer) { if (footer == null) throw new NullPointerException("Footer can't be null. Please use removeFooter() instead!"); int previousFooterItemCount = getFooterItemCount(); this.footer = footer; notifyFooterItemsChanged(previousFooterItemCount); } Section(); Section(Group header); Section(List<? extends Group> children); Section(@Nullable Group header, Collection<? extends Group> children); @Override void add(int position, Group group); @Override void addAll(Collection<? extends Group> groups); @Override void addAll(int position, List<? extends Group> groups); @Override void add(Group group); @Override void remove(Group group); @Override void removeAll(List<? extends Group> groups); void setPlaceholder(@NonNull Group placeholder); void removePlaceholder(); @Override Group getGroup(int position); @Override int getGroupCount(); @Override int getPosition(Group group); void setHeader(@NonNull Group header); void removeHeader(); void setFooter(@NonNull Group footer); void removeFooter(); void setHideWhenEmpty(boolean hide); @Override void onItemInserted(Group group, int position); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); }
@Test(expected = NullPointerException.class) public void settingNullHeaderThrowsNullPointerException() { Section section = new Section(); section.setFooter(null); } @Test(expected = NullPointerException.class) public void settingNullFooterThrowsNullPointerException() { Section section = new Section(); section.setFooter(null); } @Test public void footerCountIsSizeOfFooter() { Section section = new Section(); section.setFooter(footer); assertEquals(footerSize, section.getItemCount()); }
Section extends NestedGroup { public void removeHeader() { int previousHeaderItemCount = getHeaderItemCount(); this.header = null; notifyHeaderItemsChanged(previousHeaderItemCount); } Section(); Section(Group header); Section(List<? extends Group> children); Section(@Nullable Group header, Collection<? extends Group> children); @Override void add(int position, Group group); @Override void addAll(Collection<? extends Group> groups); @Override void addAll(int position, List<? extends Group> groups); @Override void add(Group group); @Override void remove(Group group); @Override void removeAll(List<? extends Group> groups); void setPlaceholder(@NonNull Group placeholder); void removePlaceholder(); @Override Group getGroup(int position); @Override int getGroupCount(); @Override int getPosition(Group group); void setHeader(@NonNull Group header); void removeHeader(); void setFooter(@NonNull Group footer); void removeFooter(); void setHideWhenEmpty(boolean hide); @Override void onItemInserted(Group group, int position); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); }
@Test public void headerCountIs0WhenThereIsNoHeader() { Section section = new Section(); section.removeHeader(); assertEquals(0, section.getItemCount()); }
Section extends NestedGroup { public void setHeader(@NonNull Group header) { if (header == null) throw new NullPointerException("Header can't be null. Please use removeHeader() instead!"); int previousHeaderItemCount = getHeaderItemCount(); this.header = header; notifyHeaderItemsChanged(previousHeaderItemCount); } Section(); Section(Group header); Section(List<? extends Group> children); Section(@Nullable Group header, Collection<? extends Group> children); @Override void add(int position, Group group); @Override void addAll(Collection<? extends Group> groups); @Override void addAll(int position, List<? extends Group> groups); @Override void add(Group group); @Override void remove(Group group); @Override void removeAll(List<? extends Group> groups); void setPlaceholder(@NonNull Group placeholder); void removePlaceholder(); @Override Group getGroup(int position); @Override int getGroupCount(); @Override int getPosition(Group group); void setHeader(@NonNull Group header); void removeHeader(); void setFooter(@NonNull Group footer); void removeFooter(); void setHideWhenEmpty(boolean hide); @Override void onItemInserted(Group group, int position); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); }
@Test public void headerCountIsSizeOfHeader() { Section section = new Section(); section.setHeader(header); assertEquals(headerSize, section.getItemCount()); }
Section extends NestedGroup { @Override public Group getGroup(int position) { if (isHeaderShown() && position == 0) return header; position -= getHeaderCount(); if (isPlaceholderShown() && position == 0) return placeholder; position -= getPlaceholderCount(); if (position == children.size()) { if (isFooterShown()) { return footer; } else { return null; } } else { return children.get(position); } } Section(); Section(Group header); Section(List<? extends Group> children); Section(@Nullable Group header, Collection<? extends Group> children); @Override void add(int position, Group group); @Override void addAll(Collection<? extends Group> groups); @Override void addAll(int position, List<? extends Group> groups); @Override void add(Group group); @Override void remove(Group group); @Override void removeAll(List<? extends Group> groups); void setPlaceholder(@NonNull Group placeholder); void removePlaceholder(); @Override Group getGroup(int position); @Override int getGroupCount(); @Override int getPosition(Group group); void setHeader(@NonNull Group header); void removeHeader(); void setFooter(@NonNull Group footer); void removeFooter(); void setHideWhenEmpty(boolean hide); @Override void onItemInserted(Group group, int position); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); }
@Test public void getGroup() { Section section = new Section(); Item item = new DummyItem(); section.add(item); assertEquals(0, section.getPosition(item)); }
Section extends NestedGroup { @Override public int getPosition(Group group) { int count = 0; if (isHeaderShown()) { if (group == header) return count; } count += getHeaderCount(); if (isPlaceholderShown()) { if (group == placeholder) return count; } count += getPlaceholderCount(); int index = children.indexOf(group); if (index >= 0) return count + index; count += children.size(); if (isFooterShown()) { if (footer == group) { return count; } } return -1; } Section(); Section(Group header); Section(List<? extends Group> children); Section(@Nullable Group header, Collection<? extends Group> children); @Override void add(int position, Group group); @Override void addAll(Collection<? extends Group> groups); @Override void addAll(int position, List<? extends Group> groups); @Override void add(Group group); @Override void remove(Group group); @Override void removeAll(List<? extends Group> groups); void setPlaceholder(@NonNull Group placeholder); void removePlaceholder(); @Override Group getGroup(int position); @Override int getGroupCount(); @Override int getPosition(Group group); void setHeader(@NonNull Group header); void removeHeader(); void setFooter(@NonNull Group footer); void removeFooter(); void setHideWhenEmpty(boolean hide); @Override void onItemInserted(Group group, int position); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); }
@Test public void getPositionReturnsNegativeIfItemNotPresent() { Section section = new Section(); Item item = new DummyItem(); assertEquals(-1, section.getPosition(item)); }
Section extends NestedGroup { @Override public void add(int position, Group group) { super.add(position, group); children.add(position, group); final int notifyPosition = getHeaderItemCount() + getItemCount(children.subList(0, position)); notifyItemRangeInserted(notifyPosition, group.getItemCount()); refreshEmptyState(); } Section(); Section(Group header); Section(List<? extends Group> children); Section(@Nullable Group header, Collection<? extends Group> children); @Override void add(int position, Group group); @Override void addAll(Collection<? extends Group> groups); @Override void addAll(int position, List<? extends Group> groups); @Override void add(Group group); @Override void remove(Group group); @Override void removeAll(List<? extends Group> groups); void setPlaceholder(@NonNull Group placeholder); void removePlaceholder(); @Override Group getGroup(int position); @Override int getGroupCount(); @Override int getPosition(Group group); void setHeader(@NonNull Group header); void removeHeader(); void setFooter(@NonNull Group footer); void removeFooter(); void setHideWhenEmpty(boolean hide); @Override void onItemInserted(Group group, int position); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); }
@Test public void constructorSetsListenerOnChildren() { List<Group> children = new ArrayList<>(); Item item = Mockito.mock(Item.class); children.add(item); Section section = new Section(null, children); verify(item).setGroupDataObserver(section); }
Section extends NestedGroup { @Override public void addAll(Collection<? extends Group> groups) { if (groups.isEmpty()) return; super.addAll(groups); int position = getItemCountWithoutFooter(); this.children.addAll(groups); notifyItemRangeInserted(position, getItemCount(groups)); refreshEmptyState(); } Section(); Section(Group header); Section(List<? extends Group> children); Section(@Nullable Group header, Collection<? extends Group> children); @Override void add(int position, Group group); @Override void addAll(Collection<? extends Group> groups); @Override void addAll(int position, List<? extends Group> groups); @Override void add(Group group); @Override void remove(Group group); @Override void removeAll(List<? extends Group> groups); void setPlaceholder(@NonNull Group placeholder); void removePlaceholder(); @Override Group getGroup(int position); @Override int getGroupCount(); @Override int getPosition(Group group); void setHeader(@NonNull Group header); void removeHeader(); void setFooter(@NonNull Group footer); void removeFooter(); void setHideWhenEmpty(boolean hide); @Override void onItemInserted(Group group, int position); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); }
@Test(expected = IndexOutOfBoundsException.class) public void addAllAtNonZeroPositionWhenEmptyThrowIndexOutOfBoundsException() { final Section section = new Section(); section.setGroupDataObserver(groupAdapter); section.addAll(1, Arrays.asList(new DummyItem(), new DummyItem())); }
GroupAdapter extends RecyclerView.Adapter<ViewHolder> implements GroupDataObserver { public void add(@NonNull Group group) { if (group == null) throw new RuntimeException("Group cannot be null"); int itemCountBeforeGroup = getItemCount(); group.setGroupDataObserver(this); groups.add(group); notifyItemRangeInserted(itemCountBeforeGroup, group.getItemCount()); } GridLayoutManager.SpanSizeLookup getSpanSizeLookup(); void setSpanCount(int spanCount); int getSpanCount(); void setOnItemClickListener(OnItemClickListener onItemClickListener); @Override ViewHolder<? extends ViewDataBinding> onCreateViewHolder(ViewGroup parent, int layoutResId); @Override void onBindViewHolder(ViewHolder holder, int position); @Override void onBindViewHolder(ViewHolder holder, int position, List<Object> payloads); @Override void onViewRecycled(ViewHolder holder); @Override boolean onFailedToRecycleView(ViewHolder holder); @Override int getItemViewType(int position); Item getItem(ViewHolder holder); Item getItem(int position); int getAdapterPosition(Item contentItem); int getAdapterPosition(Group group); @Override int getItemCount(); int getItemCount(int groupIndex); void clear(); void add(@NonNull Group group); void addAll(@NonNull Collection<? extends Group> groups); void remove(@NonNull Group group); void add(@NonNull int index, Group group); Group getGroup(Item contentItem); @Override void onChanged(Group group); @Override void onItemInserted(Group group, int position); @Override void onItemChanged(Group group, int position); @Override void onItemChanged(Group group, int position, Object payload); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeChanged(Group group, int positionStart, int itemCount); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); @Override void onItemMoved(Group group, int fromPosition, int toPosition); }
@Test(expected=RuntimeException.class) public void addItemMustBeNonNull() { groupAdapter.add(null); } @Test(expected=RuntimeException.class) public void putGroupMustBeNonNull() { groupAdapter.add(0, null); }
GroupAdapter extends RecyclerView.Adapter<ViewHolder> implements GroupDataObserver { public void remove(@NonNull Group group) { if (group == null) throw new RuntimeException("Group cannot be null"); int position = groups.indexOf(group); int count = groups.get(position).getItemCount(); group.setGroupDataObserver(null); groups.remove(position); notifyItemRangeRemoved(position, count); } GridLayoutManager.SpanSizeLookup getSpanSizeLookup(); void setSpanCount(int spanCount); int getSpanCount(); void setOnItemClickListener(OnItemClickListener onItemClickListener); @Override ViewHolder<? extends ViewDataBinding> onCreateViewHolder(ViewGroup parent, int layoutResId); @Override void onBindViewHolder(ViewHolder holder, int position); @Override void onBindViewHolder(ViewHolder holder, int position, List<Object> payloads); @Override void onViewRecycled(ViewHolder holder); @Override boolean onFailedToRecycleView(ViewHolder holder); @Override int getItemViewType(int position); Item getItem(ViewHolder holder); Item getItem(int position); int getAdapterPosition(Item contentItem); int getAdapterPosition(Group group); @Override int getItemCount(); int getItemCount(int groupIndex); void clear(); void add(@NonNull Group group); void addAll(@NonNull Collection<? extends Group> groups); void remove(@NonNull Group group); void add(@NonNull int index, Group group); Group getGroup(Item contentItem); @Override void onChanged(Group group); @Override void onItemInserted(Group group, int position); @Override void onItemChanged(Group group, int position); @Override void onItemChanged(Group group, int position, Object payload); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeChanged(Group group, int positionStart, int itemCount); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); @Override void onItemMoved(Group group, int fromPosition, int toPosition); }
@Test(expected=RuntimeException.class) public void removeGroupMustBeNonNull() { groupAdapter.remove(null); }
UpdatingGroup extends NestedGroup { public void update(List<? extends Item> newItems) { DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(new UpdatingCallback(newItems)); super.removeAll(items); items.clear(); super.addAll(newItems); items.addAll(newItems); diffResult.dispatchUpdatesTo(listUpdateCallback); } void update(List<? extends Item> newItems); @Override Group getGroup(int position); @Override int getGroupCount(); @Override int getPosition(Group group); }
@Test public void updateGroupChangesRange() { List<Item> children = new ArrayList<Item>(); children.add(new AlwaysUpdatingItem(1)); children.add(new AlwaysUpdatingItem(2)); UpdatingGroup group = new UpdatingGroup(); group.setGroupDataObserver(groupAdapter); group.update(children); verify(groupAdapter).onItemRangeInserted(group, 0, 2); verifyNoMoreInteractions(groupAdapter); group.update(children); verify(groupAdapter).onItemRangeChanged(group, 0, 2); verifyNoMoreInteractions(groupAdapter); } @Test public void changeAnItemNotifiesChange() { List<Item> children = new ArrayList<Item>(); Item item = new DummyItem(); children.add(item); UpdatingGroup group = new UpdatingGroup(); group.update(children); group.setGroupDataObserver(groupAdapter); item.notifyChanged(); verify(groupAdapter).onItemChanged(group, 0); }
ExpandableGroup extends NestedGroup { public boolean isExpanded() { return isExpanded; } ExpandableGroup(Group expandableItem); @Override void add(Group group); boolean isExpanded(); Group getGroup(int position); @Override int getPosition(Group group); int getGroupCount(); void onToggleExpanded(); @Override void onChanged(Group group); @Override void onItemInserted(Group group, int position); @Override void onItemChanged(Group group, int position); @Override void onItemChanged(Group group, int position, Object payload); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeChanged(Group group, int positionStart, int itemCount); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); @Override void onItemMoved(Group group, int fromPosition, int toPosition); }
@Test public void collapsedByDefault() throws Exception { ExpandableGroup expandableGroup = new ExpandableGroup(parent); assertFalse(expandableGroup.isExpanded()); }
ExpandableGroup extends NestedGroup { public Group getGroup(int position) { if (position == 0) { return parent; } else { return children.get(position - 1); } } ExpandableGroup(Group expandableItem); @Override void add(Group group); boolean isExpanded(); Group getGroup(int position); @Override int getPosition(Group group); int getGroupCount(); void onToggleExpanded(); @Override void onChanged(Group group); @Override void onItemInserted(Group group, int position); @Override void onItemChanged(Group group, int position); @Override void onItemChanged(Group group, int position, Object payload); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeChanged(Group group, int positionStart, int itemCount); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); @Override void onItemMoved(Group group, int fromPosition, int toPosition); }
@Test public void testGetGroup() throws Exception { ExpandableGroup expandableGroup = new ExpandableGroup(parent); Section section = new Section(); int sectionSize = 5; for (int i = 0; i < sectionSize; i++) { section.add(new DummyItem()); } expandableGroup.add(section); Item lastItem = new DummyItem(); expandableGroup.add(lastItem); expandableGroup.onToggleExpanded(); assertEquals(lastItem, expandableGroup.getGroup(2)); }
ExpandableGroup extends NestedGroup { @Override public int getPosition(Group group) { if (group == parent) { return 0; } else { return 1 + children.indexOf(group); } } ExpandableGroup(Group expandableItem); @Override void add(Group group); boolean isExpanded(); Group getGroup(int position); @Override int getPosition(Group group); int getGroupCount(); void onToggleExpanded(); @Override void onChanged(Group group); @Override void onItemInserted(Group group, int position); @Override void onItemChanged(Group group, int position); @Override void onItemChanged(Group group, int position, Object payload); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeChanged(Group group, int positionStart, int itemCount); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); @Override void onItemMoved(Group group, int fromPosition, int toPosition); }
@Test public void testGetHeaderPosition() throws Exception { ExpandableGroup expandableGroup = new ExpandableGroup(parent); assertEquals(0, expandableGroup.getPosition(parent)); }
Section extends NestedGroup { public void removeFooter() { int previousFooterItemCount = getFooterItemCount(); this.footer = null; notifyFooterItemsChanged(previousFooterItemCount); } Section(); Section(Group header); Section(List<? extends Group> children); Section(@Nullable Group header, Collection<? extends Group> children); @Override void add(int position, Group group); @Override void addAll(Collection<? extends Group> groups); @Override void addAll(int position, List<? extends Group> groups); @Override void add(Group group); @Override void remove(Group group); @Override void removeAll(List<? extends Group> groups); void setPlaceholder(@NonNull Group placeholder); void removePlaceholder(); @Override Group getGroup(int position); @Override int getGroupCount(); @Override int getPosition(Group group); void setHeader(@NonNull Group header); void removeHeader(); void setFooter(@NonNull Group footer); void removeFooter(); void setHideWhenEmpty(boolean hide); @Override void onItemInserted(Group group, int position); @Override void onItemRemoved(Group group, int position); @Override void onItemRangeInserted(Group group, int positionStart, int itemCount); @Override void onItemRangeRemoved(Group group, int positionStart, int itemCount); }
@Test public void footerCountIs0WhenThereIsNoFooter() { Section section = new Section(); section.removeFooter(); assertEquals(0, section.getItemCount()); }
Table implements Iterable<TableRow> { public static <T> T[] parse(final Class<T> rowType, final String[] headerAndRows) { return parse(rowType, headerAndRows, new SpockitoValueConverter()); } private Table(); private Table(final String headerString); int getColumnCount(); int getColumnIndexByName(final String columnName); boolean hasColumn(final String columnName); int getRowCount(); String getColumnName(final int index); TableRow getRow(final int rowIndex); int getRowIndex(final TableRow row); String getValue(final int rowIndex, final int columnIndex); String getValue(final int rowIndex, final String columnName); @Override Iterator<TableRow> iterator(); static T[] parse(final Class<T> rowType, final String[] headerAndRows); static T[] parse(final Class<T> rowType, final String[] headerAndRows, final ValueConverter valueConverter); static Table parse(final String[] headerAndRows); }
@Test public void parse() { final Row[] rows = Table.parse(Row.class, new String[] { "| index | listOfInteger | emptyString |", "| 0 | [1;2;3;4;5;6] | |", "| 1 | [9;8;7;6;5;4] | '' |" }); assertEquals(2, rows.length, "unexpected row count"); for (int row = 0; row < rows.length; row++) { assertEquals(row, rows[row].index, "unexpected index"); assertEquals(6, rows[row].listOfInteger.size(), "unexpected list size"); assertEquals("", rows[row].emptyString, "string should be empty"); } }
BindingSet implements BindingInformationProvider { static String asHumanDescription(Collection<? extends MemberViewBinding> bindings) { Iterator<? extends MemberViewBinding> iterator = bindings.iterator(); switch (bindings.size()) { case 1: return iterator.next().getDescription(); case 2: return iterator.next().getDescription() + " and " + iterator.next().getDescription(); default: StringBuilder builder = new StringBuilder(); for (int i = 0, count = bindings.size(); i < count; i++) { if (i != 0) { builder.append(", "); } if (i == count - 1) { builder.append("and "); } builder.append(iterator.next().getDescription()); } return builder.toString(); } } private BindingSet( TypeName targetTypeName, ClassName bindingClassName, TypeElement enclosingElement, boolean isFinal, boolean isView, boolean isActivity, boolean isDialog, ImmutableList<ViewBinding> viewBindings, ImmutableList<FieldCollectionViewBinding> collectionBindings, ImmutableList<ResourceBinding> resourceBindings, @Nullable BindingInformationProvider parentBinding); @Override ClassName getBindingClassName(); @Override boolean constructorNeedsView(); @Override String toString(); }
@Test public void humanDescriptionJoinWorks() { MemberViewBinding one = new TestViewBinding("one"); MemberViewBinding two = new TestViewBinding("two"); MemberViewBinding three = new TestViewBinding("three"); String result1 = asHumanDescription(singletonList(one)); assertThat(result1).isEqualTo("one"); String result2 = asHumanDescription(asList(one, two)); assertThat(result2).isEqualTo("one and two"); String result3 = asHumanDescription(asList(one, two, three)); assertThat(result3).isEqualTo("one, two, and three"); }
LintRegistry extends IssueRegistry { @Override public List<Issue> getIssues() { return ImmutableList.of(InvalidR2UsageDetector.ISSUE); } @Override List<Issue> getIssues(); @Override int getApi(); }
@Test public void issues() { assertThat(new LintRegistry().getIssues()).contains(InvalidR2UsageDetector.ISSUE); }
RxRequestBody extends RequestBody { @Override public void writeTo(@NonNull BufferedSink sink) throws IOException { try (final Source source = Okio.source(inputStream)) { final long total = contentLength(); long remaining = total; long size = Math.min(BUFFER_SIZE, remaining); progressEmitter.onNext(Status.createSending(jobId, 0)); while (remaining > 0) { sink.write(source, size); remaining = Math.max(0, remaining - size); size = Math.min(BUFFER_SIZE, remaining); final int progress = (int) (100 - ((float) remaining / total) * 100); progressEmitter.onNext(Status.createSending(jobId, progress)); } } } @VisibleForTesting RxRequestBody(@NonNull Emitter<Status> progressEmitter, @NonNull String jobId, @NonNull MediaType mediaType, @NonNull InputStream inputStream, long length); @NonNull static RequestBody create(@NonNull Emitter<Status> progressEmitter, @NonNull String jobId, @NonNull File file, @NonNull String mimeType); @NonNull @Override MediaType contentType(); @Override long contentLength(); @Override void writeTo(@NonNull BufferedSink sink); static final long BUFFER_SIZE; }
@Test public void testWrite() throws Exception { final String jobId = "test-job-id"; final long length = RxRequestBody.BUFFER_SIZE * 3; final BufferedSink sink = mock(BufferedSink.class); final InputStream inputStream = mock(InputStream.class); final Emitter<Status> emitter = mock(Emitter.class); final RequestBody requestBody = new RxRequestBody(emitter, jobId, MediaType.parse("text/plain"), inputStream, length); requestBody.writeTo(sink); verify(sink, times(3)).write(any(Source.class), anyLong()); verify(emitter).onNext(Status.createSending(jobId, 0)); verify(emitter).onNext(Status.createSending(jobId, 33)); verify(emitter).onNext(Status.createSending(jobId, 66)); verify(emitter).onNext(Status.createSending(jobId, 100)); } @Test public void testWriteEmpty() throws Exception { final String jobId = "test-job-id"; final long length = 0; final BufferedSink sink = mock(BufferedSink.class); final InputStream inputStream = mock(InputStream.class); final Emitter<Status> emitter = mock(Emitter.class); final RequestBody requestBody = new RxRequestBody(emitter, jobId, MediaType.parse("text/plain"), inputStream, length); requestBody.writeTo(sink); verify(sink, times(0)).write(any(Source.class), anyLong()); verify(emitter).onNext(Status.createSending(jobId, 0)); } @Test public void testWriteSmall() throws Exception { final String jobId = "test-job-id"; final long length = 1; final BufferedSink sink = mock(BufferedSink.class); final InputStream inputStream = mock(InputStream.class); final Emitter<Status> emitter = mock(Emitter.class); final RequestBody requestBody = new RxRequestBody(emitter, jobId, MediaType.parse("text/plain"), inputStream, length); requestBody.writeTo(sink); verify(sink, times(1)).write(any(Source.class), anyLong()); verify(emitter).onNext(Status.createSending(jobId, 0)); verify(emitter).onNext(Status.createSending(jobId, 100)); } @Test(expected = IOException.class) public void testWriteError() throws Exception { final String jobId = "test-job-id"; final long length = RxRequestBody.BUFFER_SIZE * 3; final BufferedSink sink = mock(BufferedSink.class); final InputStream inputStream = mock(InputStream.class); final Emitter<Status> emitter = mock(Emitter.class); final RequestBody requestBody = new RxRequestBody(emitter, jobId, MediaType.parse("text/plain"), inputStream, length); when(sink.write(any(Source.class), anyInt())).thenThrow(new IOException("Error")); requestBody.writeTo(sink); verify(sink, times(3)).write(any(Source.class), anyLong()); verify(emitter).onNext(Status.createSending(jobId, 0)); }
SimpleUploadDataStore implements UploadDataStore { @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override public Observable<Job> save(@NonNull Job job) { return Observable.fromCallable(() -> { final String rawJob = gson.toJson(job); sharedPreferences.edit().putString(jobIdKey(job.id()), rawJob).commit(); final Set<String> keys = sharedPreferences.getStringSet(KEY_JOB_IDS, new HashSet<>()); keys.add(jobIdKey(job.id())); sharedPreferences.edit().putStringSet(KEY_JOB_IDS, keys).commit(); return job; }).subscribeOn(worker); } @VisibleForTesting SimpleUploadDataStore(@NonNull SharedPreferences sharedPreferences, @NonNull Scheduler worker); @NonNull static UploadDataStore create(@NonNull Context context); @NonNull @Override Observable<Job> get(@NonNull String jobId); @NonNull @Override Observable<Job> getAll(); @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override Observable<Job> save(@NonNull Job job); @SuppressLint("CommitPrefEdits") @NonNull @Override Observable<Job> update(@NonNull Status status); @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override Observable<Job> delete(@NonNull String id); }
@Test public void save() throws Exception { final Job job = Job.builder() .setId("job_id_1") .setFilepath("test/file/path/1") .setMetadata(Collections.emptyMap()) .setMimeType("text/plain") .setStatus(Status.createQueued("job_id_1")) .build(); final TestSubscriber<Job> ts = TestSubscriber.create(); dataStore.save(job).subscribe(ts); ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); ts.assertValueCount(1); ts.assertValue(job); final TestSubscriber<Job> ts2 = TestSubscriber.create(); dataStore.getAll().subscribe(ts2); ts2.awaitTerminalEvent(1, TimeUnit.SECONDS); ts2.assertNoErrors(); ts2.assertCompleted(); ts2.assertValueCount(1); ts2.assertValue(job); }
SimpleUploadDataStore implements UploadDataStore { @SuppressLint("CommitPrefEdits") @NonNull @Override public Observable<Job> update(@NonNull Status status) { return get(status.id()) .filter(job -> !Job.isInvalid(job)) .flatMap(job -> save(job.withStatus(status))) .defaultIfEmpty(Job.INVALID_JOB); } @VisibleForTesting SimpleUploadDataStore(@NonNull SharedPreferences sharedPreferences, @NonNull Scheduler worker); @NonNull static UploadDataStore create(@NonNull Context context); @NonNull @Override Observable<Job> get(@NonNull String jobId); @NonNull @Override Observable<Job> getAll(); @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override Observable<Job> save(@NonNull Job job); @SuppressLint("CommitPrefEdits") @NonNull @Override Observable<Job> update(@NonNull Status status); @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override Observable<Job> delete(@NonNull String id); }
@Test public void update() throws Exception { final Job test = createTestJob(); final String json = gson.toJson(test); final String key = SimpleUploadDataStore.jobIdKey(test.id()); final Set<String> keys = new HashSet<>(); keys.add(key); final SharedPreferences.Editor editor = sharedPreferences.edit(); editor.putStringSet(SimpleUploadDataStore.KEY_JOB_IDS, keys); editor.putString(key, json); editor.apply(); final TestSubscriber<Job> ts = TestSubscriber.create(); dataStore.update(Status.createCompleted(test.id(), null)).subscribe(ts); ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); ts.assertValueCount(1); ts.assertValue(test.withStatus(Status.createCompleted(test.id(), null))); }
SimpleUploadDataStore implements UploadDataStore { @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override public Observable<Job> delete(@NonNull String id) { return get(id) .filter(job -> !Job.isInvalid(job)) .doOnNext(job -> { sharedPreferences.edit().remove(jobIdKey(job.id())).commit(); final Set<String> keys = sharedPreferences .getStringSet(KEY_JOB_IDS, Collections.emptySet()); keys.remove(jobIdKey(id)); sharedPreferences.edit().putStringSet(KEY_JOB_IDS, keys).commit(); }) .defaultIfEmpty(Job.INVALID_JOB); } @VisibleForTesting SimpleUploadDataStore(@NonNull SharedPreferences sharedPreferences, @NonNull Scheduler worker); @NonNull static UploadDataStore create(@NonNull Context context); @NonNull @Override Observable<Job> get(@NonNull String jobId); @NonNull @Override Observable<Job> getAll(); @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override Observable<Job> save(@NonNull Job job); @SuppressLint("CommitPrefEdits") @NonNull @Override Observable<Job> update(@NonNull Status status); @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override Observable<Job> delete(@NonNull String id); }
@SuppressLint("ApplySharedPref") @Test public void delete() throws Exception { final Job test = createTestJob(); final String json = gson.toJson(test); final String key = SimpleUploadDataStore.jobIdKey(test.id()); final Set<String> keys = new HashSet<>(); keys.add(key); final SharedPreferences.Editor editor = sharedPreferences.edit(); editor.putStringSet(SimpleUploadDataStore.KEY_JOB_IDS, keys); editor.putString(key, json); editor.commit(); final TestSubscriber<Job> ts = TestSubscriber.create(); dataStore.delete(test.id()).subscribe(ts); ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); ts.assertValueCount(1); ts.assertValue(test); final TestSubscriber<Job> ts2 = TestSubscriber.create(); dataStore.getAll().subscribe(ts2); ts2.awaitTerminalEvent(1, TimeUnit.SECONDS); ts2.assertNoErrors(); ts2.assertCompleted(); ts2.assertNoValues(); }
StringUtils { public static boolean isNullOrEmpty(@Nullable CharSequence s) { return s == null || s.length() == 0; } private StringUtils(); static boolean isNullOrEmpty(@Nullable CharSequence s); @NonNull static String getOrDefault(@Nullable String s, @NonNull String t); @NonNull static String getOrEmpty(@Nullable String s); }
@Test public void testIsNull() throws Exception { assertThat(StringUtils.isNullOrEmpty(null), is(true)); } @Test public void testIsNotNull() throws Exception { assertThat(StringUtils.isNullOrEmpty("not null"), is(false)); } @Test public void testIsEmpty() throws Exception { assertThat(StringUtils.isNullOrEmpty(""), is(true)); } @Test public void testIsNotEmpty() throws Exception { assertThat(StringUtils.isNullOrEmpty("not empty"), is(false)); }
StringUtils { @NonNull public static String getOrDefault(@Nullable String s, @NonNull String t) { return s != null ? s : t; } private StringUtils(); static boolean isNullOrEmpty(@Nullable CharSequence s); @NonNull static String getOrDefault(@Nullable String s, @NonNull String t); @NonNull static String getOrEmpty(@Nullable String s); }
@Test public void testGetNonEmptyString() throws Exception { assertThat(StringUtils.getOrDefault("not empty", "invalid"), is(equalTo("not empty"))); } @Test public void testGetEmptyString() throws Exception { assertThat(StringUtils.getOrDefault("", "invalid"), is(equalTo(""))); } @Test public void testGetDefaultString() throws Exception { assertThat(StringUtils.getOrDefault(null, "default"), is(equalTo("default"))); }
StringUtils { @NonNull public static String getOrEmpty(@Nullable String s) { return getOrDefault(s, ""); } private StringUtils(); static boolean isNullOrEmpty(@Nullable CharSequence s); @NonNull static String getOrDefault(@Nullable String s, @NonNull String t); @NonNull static String getOrEmpty(@Nullable String s); }
@Test public void testGetEmptyStringForNull() throws Exception { assertThat(StringUtils.getOrEmpty(null), is(equalTo(""))); } @Test public void testGetEmptyStringForNonNull() throws Exception { assertThat(StringUtils.getOrEmpty("not empty"), is(equalTo("not empty"))); }
UploadInteractorImpl implements UploadInteractor { @NonNull @Override public Observable<Status> upload(@NonNull String id) { return get(id) .filter(job -> !Job.isInvalid(job)) .observeOn(networkScheduler) .flatMap(job -> { final File file = new File(job.filepath()); if (!file.exists()) { return Observable.error(new FileNotFoundException()); } return uploader .upload(job, file) .distinctUntilChanged(); }) .defaultIfEmpty(Status.createInvalid(id)); } @VisibleForTesting UploadInteractorImpl(@NonNull Uploader uploader, @NonNull UploadDataStore dataStore, @NonNull UploadErrorAdapter errorAdapter, @NonNull Scheduler networkScheduler); @NonNull @Override Observable<Job> get(@NonNull String id); @NonNull @Override Observable<Job> getAll(); @NonNull @Override Observable<Job> save(@NonNull Job job); @NonNull @Override Observable<Job> update(@NonNull Status status); @NonNull @Override Observable<Job> delete(@NonNull String id); @NonNull @Override Observable<Status> upload(@NonNull String id); }
@Test public void testUpload() throws Exception { final String jobId = "job-id"; final File file = getFile(TEST_FILE); final Job job = Job.builder() .setId(jobId) .setFilepath(file.getPath()) .setMetadata(Collections.emptyMap()) .setMimeType("text/plain") .setStatus(Status.createQueued(jobId)) .build(); when(dataStore.get(jobId)).thenReturn(Observable.just(job)); final Status[] statuses = new Status[] { Status.createSending(jobId, 0), Status.createSending(jobId, 10), Status.createSending(jobId, 20), Status.createSending(jobId, 30), Status.createSending(jobId, 40), Status.createSending(jobId, 50), Status.createSending(jobId, 60), Status.createSending(jobId, 70), Status.createSending(jobId, 80), Status.createSending(jobId, 90), Status.createSending(jobId, 100), Status.createCompleted(jobId, "Finished"), }; when(uploader.upload(job, file)).thenReturn(Observable.from(statuses)); final TestSubscriber<Status> ts = TestSubscriber.create(); uploadInteractor.upload(jobId).subscribe(ts); testScheduler.triggerActions(); ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); ts.assertValues(statuses); }
UploadManager { public void enqueue(@NonNull Job job) { jobSubject.onNext(job); } @VisibleForTesting UploadManager(@NonNull UploadInteractor uploadInteractor, @NonNull UploadErrorAdapter errorAdapter, @NonNull Subject<Job, Job> jobSubject, @NonNull Subject<Status, Status> statusSubject, boolean deleteRecordOnComplete); @NonNull Observable<Status> status(); void enqueue(@NonNull Job job); void retry(@NonNull String jobId); void retryAll(); @NonNull Observable<Job> getJob(@NonNull String jobId); @NonNull static Builder builder(); }
@Test public void testEnqueue() throws Exception { when(uploadInteractor.save(TEST_JOB)) .thenReturn(Observable.just(TEST_JOB)); when(uploadInteractor.update(TEST_JOB.status())) .thenReturn(Observable.just(TEST_JOB)); final Status completed = Status.createCompleted(TEST_JOB.id(), "Finished"); when(uploadInteractor.update(completed)) .thenReturn(Observable.just(TEST_JOB.withStatus(completed))); final Status[] statuses = new Status[] { Status.createSending(TEST_JOB.id(), 0), Status.createSending(TEST_JOB.id(), 50), Status.createSending(TEST_JOB.id(), 100), completed, }; when(uploadInteractor.upload(TEST_JOB.id())) .thenReturn(Observable.from(statuses)); when(uploadInteractor.delete(TEST_JOB.id())) .thenReturn(Observable.just(TEST_JOB.withStatus(completed))); uploadManager.enqueue(TEST_JOB); testScheduler.triggerActions(); verify(uploadInteractor).save(TEST_JOB); verify(uploadInteractor).update(TEST_JOB.status()); verify(uploadInteractor).upload(TEST_JOB.id()); verify(uploadInteractor).update(completed); }
UploadManager { @NonNull public static Builder builder() { return new Builder(); } @VisibleForTesting UploadManager(@NonNull UploadInteractor uploadInteractor, @NonNull UploadErrorAdapter errorAdapter, @NonNull Subject<Job, Job> jobSubject, @NonNull Subject<Status, Status> statusSubject, boolean deleteRecordOnComplete); @NonNull Observable<Status> status(); void enqueue(@NonNull Job job); void retry(@NonNull String jobId); void retryAll(); @NonNull Observable<Job> getJob(@NonNull String jobId); @NonNull static Builder builder(); }
@Test public void testDanglingUpload() { final String jobId1 = "job-id-1"; final String jobId2 = "job-id-2"; final Job job1 = Job.builder() .setId(jobId1) .setFilepath("filepath") .setMetadata(Collections.emptyMap()) .setStatus(createQueued(jobId1)) .setMimeType("text/plain") .build(); final Job job2 = Job.builder() .setId(jobId2) .setFilepath("filepath") .setMetadata(Collections.emptyMap()) .setStatus(createSending(jobId2, 0)) .setMimeType("text/plain") .build(); when(uploadInteractor.getAll()) .thenReturn(Observable.from(Arrays.asList(job1, job2))); final TestScheduler testScheduler = new TestScheduler(); final TestSubject<Status> statusSubject = TestSubject.create(testScheduler); final TestSubject<Job> jobSubject = TestSubject.create(testScheduler); new UploadManager(uploadInteractor, uploadErrorAdapter, jobSubject, statusSubject, false); verify(uploadInteractor, times(1)).update(any(Status.class)); final Status expectedStatus = Status.createFailed(job2.id(), ErrorType.TERMINATED); verify(uploadInteractor).update(expectedStatus); }
RxRequestBody extends RequestBody { @Override public long contentLength() { return length; } @VisibleForTesting RxRequestBody(@NonNull Emitter<Status> progressEmitter, @NonNull String jobId, @NonNull MediaType mediaType, @NonNull InputStream inputStream, long length); @NonNull static RequestBody create(@NonNull Emitter<Status> progressEmitter, @NonNull String jobId, @NonNull File file, @NonNull String mimeType); @NonNull @Override MediaType contentType(); @Override long contentLength(); @Override void writeTo(@NonNull BufferedSink sink); static final long BUFFER_SIZE; }
@Test public void testContentLength() throws Exception { final String jobId = "test-job-id"; final long length = RxRequestBody.BUFFER_SIZE * 3; final InputStream inputStream = mock(InputStream.class); final Emitter<Status> emitter = mock(Emitter.class); final RequestBody requestBody = new RxRequestBody(emitter, jobId, MediaType.parse("text/plain"), inputStream, length); assertThat(requestBody.contentLength(), is(length)); }
RxRequestBody extends RequestBody { @NonNull @Override public MediaType contentType() { return mediaType; } @VisibleForTesting RxRequestBody(@NonNull Emitter<Status> progressEmitter, @NonNull String jobId, @NonNull MediaType mediaType, @NonNull InputStream inputStream, long length); @NonNull static RequestBody create(@NonNull Emitter<Status> progressEmitter, @NonNull String jobId, @NonNull File file, @NonNull String mimeType); @NonNull @Override MediaType contentType(); @Override long contentLength(); @Override void writeTo(@NonNull BufferedSink sink); static final long BUFFER_SIZE; }
@Test public void testContentType() throws Exception { final String jobId = "test-job-id"; final long length = RxRequestBody.BUFFER_SIZE * 3; final InputStream inputStream = mock(InputStream.class); final Emitter<Status> emitter = mock(Emitter.class); final MediaType mediaType = MediaType.parse("text/plain"); final RequestBody requestBody = new RxRequestBody(emitter, jobId, mediaType, inputStream, length); assertThat(requestBody.contentType(), is(mediaType)); }
Uploader { @NonNull public Observable<Status> upload(@NonNull Job job, @NonNull File file) { final String name = StringUtils.getOrDefault(formDataName, DEFAULT_FORM_DATA_NAME); return new UploadObservable(uploadService, job, file, name) .create() .subscribeOn(worker); } @VisibleForTesting Uploader(@NonNull UploadService uploadService, @NonNull Scheduler worker); void setFormDataName(@NonNull String name); @NonNull Observable<Status> upload(@NonNull Job job, @NonNull File file); }
@Test public void testUpload() throws Exception { final File file = getFile(TEST_FILE); final String jobId = "job-id"; final Job job = Job.builder() .setId(jobId) .setStatus(Status.createQueued(jobId)) .setMetadata(Collections.emptyMap()) .setFilepath(file.getPath()) .setMimeType("text/plain") .build(); final BufferedSink sink = mock(BufferedSink.class); final List<Status> values = new ArrayList<>(); values.add(Status.createSending(jobId, 0)); final long total = file.length(); long consumed = 0; while (consumed < total) { consumed = Math.min(total, consumed + RxRequestBody.BUFFER_SIZE); values.add(Status.createSending(jobId, (int) ((float) consumed * 100 / total))); } values.add(Status.createCompleted(jobId, "complete")); final Status[] expectedStatus = new Status[values.size()]; values.toArray(expectedStatus); final UploadService service = (__, data) -> { try { data.body().writeTo(sink); } catch (@NonNull IOException e) { Single.error(e); } return Single.just("complete"); }; final Uploader uploader = new Uploader(service, Schedulers.io()); final TestSubscriber<Status> ts = TestSubscriber.create(); uploader.upload(job, file).subscribe(ts); ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); ts.assertValues(expectedStatus); }
SimpleUploadDataStore implements UploadDataStore { @VisibleForTesting @NonNull static String jobIdKey(@NonNull String jobId) { return KEY_JOB_ID_PREFIX + jobId; } @VisibleForTesting SimpleUploadDataStore(@NonNull SharedPreferences sharedPreferences, @NonNull Scheduler worker); @NonNull static UploadDataStore create(@NonNull Context context); @NonNull @Override Observable<Job> get(@NonNull String jobId); @NonNull @Override Observable<Job> getAll(); @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override Observable<Job> save(@NonNull Job job); @SuppressLint("CommitPrefEdits") @NonNull @Override Observable<Job> update(@NonNull Status status); @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override Observable<Job> delete(@NonNull String id); }
@Test public void testJobIdKey() throws Exception { final String expectedJobIdKey = SimpleUploadDataStore.KEY_JOB_ID_PREFIX + TEST_JOB_ID; assertThat(SimpleUploadDataStore.jobIdKey(TEST_JOB_ID), is(expectedJobIdKey)); }
SimpleUploadDataStore implements UploadDataStore { @NonNull @Override public Observable<Job> get(@NonNull String jobId) { return Observable.fromCallable(() -> getJob(jobIdKey(jobId))).subscribeOn(worker); } @VisibleForTesting SimpleUploadDataStore(@NonNull SharedPreferences sharedPreferences, @NonNull Scheduler worker); @NonNull static UploadDataStore create(@NonNull Context context); @NonNull @Override Observable<Job> get(@NonNull String jobId); @NonNull @Override Observable<Job> getAll(); @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override Observable<Job> save(@NonNull Job job); @SuppressLint("CommitPrefEdits") @NonNull @Override Observable<Job> update(@NonNull Status status); @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override Observable<Job> delete(@NonNull String id); }
@SuppressLint("ApplySharedPref") @Test public void testGet() throws Exception { final Job test = createTestJob(); final String json = gson.toJson(test); final String key = SimpleUploadDataStore.jobIdKey(test.id()); final Set<String> keys = new HashSet<>(); keys.add(key); final SharedPreferences.Editor editor = sharedPreferences.edit(); editor.putStringSet(SimpleUploadDataStore.KEY_JOB_IDS, keys); editor.putString(key, json); editor.commit(); final TestSubscriber<Job> ts = TestSubscriber.create(); dataStore.get(test.id()).subscribe(ts); ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); ts.assertValueCount(1); ts.assertValue(test); }
SimpleUploadDataStore implements UploadDataStore { @NonNull @Override public Observable<Job> getAll() { return Observable.fromCallable(new Callable<Set<Job>>() { @Override public Set<Job> call() throws Exception { final Set<String> jobIdKeys = sharedPreferences .getStringSet(KEY_JOB_IDS, Collections.emptySet()); if (jobIdKeys.isEmpty()) { return Collections.emptySet(); } final Set<Job> jobs = new HashSet<>(jobIdKeys.size()); for (String key : jobIdKeys) { jobs.add(getJob(key)); } return jobs; } }).flatMap(Observable::from).subscribeOn(worker); } @VisibleForTesting SimpleUploadDataStore(@NonNull SharedPreferences sharedPreferences, @NonNull Scheduler worker); @NonNull static UploadDataStore create(@NonNull Context context); @NonNull @Override Observable<Job> get(@NonNull String jobId); @NonNull @Override Observable<Job> getAll(); @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override Observable<Job> save(@NonNull Job job); @SuppressLint("CommitPrefEdits") @NonNull @Override Observable<Job> update(@NonNull Status status); @SuppressLint({ "CommitPrefEdits", "ApplySharedPref" }) @NonNull @Override Observable<Job> delete(@NonNull String id); }
@SuppressLint("ApplySharedPref") @Test public void testGetAll() throws Exception { final Job job1 = Job.builder() .setId("job_id_1") .setFilepath("test/file/path/1") .setMetadata(Collections.emptyMap()) .setMimeType("text/plain") .setStatus(Status.createQueued("job_id_1")) .build(); final Job job2 = Job.builder() .setId("job_id_2") .setFilepath("test/file/path/2") .setMetadata(Collections.emptyMap()) .setMimeType("text/plain") .setStatus(Status.createCompleted("job_id_2", null)) .build(); final Job job3 = Job.builder() .setId("job_id_3") .setFilepath("test/file/path/3") .setMetadata(Collections.emptyMap()) .setMimeType("text/plain") .setStatus(Status.createFailed("job_id_3", ErrorType.SERVICE)) .build(); final Set<String> keys = new HashSet<>(); keys.add(SimpleUploadDataStore.jobIdKey(job1.id())); keys.add(SimpleUploadDataStore.jobIdKey(job2.id())); keys.add(SimpleUploadDataStore.jobIdKey(job3.id())); final SharedPreferences.Editor editor = sharedPreferences.edit(); editor.putStringSet(SimpleUploadDataStore.KEY_JOB_IDS, keys); editor.putString(SimpleUploadDataStore.jobIdKey(job1.id()), gson.toJson(job1)); editor.putString(SimpleUploadDataStore.jobIdKey(job2.id()), gson.toJson(job2)); editor.putString(SimpleUploadDataStore.jobIdKey(job3.id()), gson.toJson(job3)); editor.commit(); final TestSubscriber<Job> ts = TestSubscriber.create(); dataStore.getAll().subscribe(ts); ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); ts.assertCompleted(); ts.assertValueCount(3); final List<Job> jobs = ts.getOnNextEvents(); assertThat(jobs, containsInAnyOrder(job1, job2, job3)); }