Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public ValidationMode getValidationMode() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetValidationMode() { pui.getValidationMode(); }
### Question: MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public String getPersistenceXMLSchemaVersion() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetPersistenceXMLSchemaVersion() { pui.getPersistenceXMLSchemaVersion(); }
### Question: MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public ClassLoader getClassLoader() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetClassLoader() { pui.getClassLoader(); }
### Question: MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public void addTransformer(final ClassTransformer transformer) { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testAddTransformer() { pui.addTransformer(null); }
### Question: MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public ClassLoader getNewTempClassLoader() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetNewTempClassLoader() { pui.getNewTempClassLoader(); }
### Question: Parser { private MinijaxCriteriaQuery<T> parseSelect() { consume(TokenType.KEYWORD_SELECT); query = cb.createQuery(resultType); while (getCurr().getTokenType() != TokenType.KEYWORD_FROM) { index++; } consume(TokenType.KEYWORD_FROM); final MinijaxEntityType<T> resultEntityType = cb.getMetamodel().entity(resultType); final String entityTypeName = consume(TokenType.SYMBOL).getValue(); if (!resultEntityType.getName().equals(entityTypeName)) { throw new PersistenceException( "Result type does not match entity type name (resultEntityType=" + resultEntityType.getName() + ", entityTypeName=" + entityTypeName + ")"); } root = query.from(resultType); final String entityTypeAlias = consume(TokenType.SYMBOL).getValue(); root.alias(entityTypeAlias); while (!eof()) { final Token curr = getCurr(); switch (curr.getTokenType()) { case KEYWORD_WHERE: parseWhere(); break; case KEYWORD_ORDER: parseOrderBy(); break; default: throw new PersistenceException("Unexpected token: " + curr); } } return query; } private Parser(final MinijaxCriteriaBuilder cb, final Class<T> resultType, final List<Token> tokens); static MinijaxCriteriaQuery<T> parse(final MinijaxCriteriaBuilder cb, final Class<T> resultType, final List<Token> tokens); }### Answer: @Test public void testParseSelect() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w WHERE id = :id")); assertNotNull(query); }
### Question: Hello { @GET public static String hello() { return "Hello world!"; } @GET static String hello(); static void main(String[] args); }### Answer: @Test public void testHello() { assertEquals("Hello world!", target("/").request().get(String.class)); }
### Question: Parser { private void parseOrderBy() { consume(TokenType.KEYWORD_ORDER); consume(TokenType.KEYWORD_BY); final MinijaxPath<?> path = parsePath(); boolean ascending = true; if (index < tokens.size()) { final Token curr = getCurr(); if (curr.getTokenType() == TokenType.KEYWORD_ASC) { consume(TokenType.KEYWORD_ASC); } else if (curr.getTokenType() == TokenType.KEYWORD_DESC) { consume(TokenType.KEYWORD_DESC); ascending = false; } } query.orderBy(new MinijaxOrder(path, ascending)); } private Parser(final MinijaxCriteriaBuilder cb, final Class<T> resultType, final List<Token> tokens); static MinijaxCriteriaQuery<T> parse(final MinijaxCriteriaBuilder cb, final Class<T> resultType, final List<Token> tokens); }### Answer: @Test public void testParseOrderBy() { final MinijaxCriteriaQuery<Widget> query = Parser.parse( em.getCriteriaBuilder(), Widget.class, Tokenizer.tokenize("SELECT w FROM Widget w ORDER BY w.name")); assertNotNull(query); }
### Question: App { @GET @Path("/") public static String hello() { return "Hello world!"; } @GET @Path("/") static String hello(); static void main(final String[] args); }### Answer: @Test public void testHello() { assertEquals("Hello world!", target("/").request().get(String.class)); }
### Question: MinijaxEntityManagerFactory implements javax.persistence.EntityManagerFactory, AutoCloseable { @Override public MinijaxEntityManager createEntityManager() { return new MinijaxEntityManager(this, metamodel, dialect, createConnection()); } @SuppressWarnings({ "unchecked", "rawtypes" }) MinijaxEntityManagerFactory(final MinijaxPersistenceUnitInfo unitInfo, final Map<String, Object> properties); MinijaxPersistenceUnitInfo getPersistenceUnitInfo(); @Override MinijaxMetamodel getMetamodel(); @Override Map<String, Object> getProperties(); @Override MinijaxEntityManager createEntityManager(); @Override void close(); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final Map map); @Override EntityManager createEntityManager(final SynchronizationType synchronizationType); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final SynchronizationType synchronizationType, final Map map); @Override CriteriaBuilder getCriteriaBuilder(); @Override boolean isOpen(); @Override Cache getCache(); @Override PersistenceUnitUtil getPersistenceUnitUtil(); @Override void addNamedQuery(final String name, final Query query); @Override T unwrap(final Class<T> cls); @Override void addNamedEntityGraph(final String graphName, final EntityGraph<T> entityGraph); }### Answer: @Test(expected = UnsupportedOperationException.class) @SuppressWarnings("rawtypes") public void testCreateEntityManager1() { emf.createEntityManager((Map) null); } @Test(expected = UnsupportedOperationException.class) public void testCreateEntityManager2() { emf.createEntityManager((SynchronizationType) null); } @Test(expected = UnsupportedOperationException.class) @SuppressWarnings("rawtypes") public void testCreateEntityManager3() { emf.createEntityManager((SynchronizationType) null, (Map) null); }
### Question: MinijaxEntityManagerFactory implements javax.persistence.EntityManagerFactory, AutoCloseable { @Override public CriteriaBuilder getCriteriaBuilder() { throw new UnsupportedOperationException(); } @SuppressWarnings({ "unchecked", "rawtypes" }) MinijaxEntityManagerFactory(final MinijaxPersistenceUnitInfo unitInfo, final Map<String, Object> properties); MinijaxPersistenceUnitInfo getPersistenceUnitInfo(); @Override MinijaxMetamodel getMetamodel(); @Override Map<String, Object> getProperties(); @Override MinijaxEntityManager createEntityManager(); @Override void close(); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final Map map); @Override EntityManager createEntityManager(final SynchronizationType synchronizationType); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final SynchronizationType synchronizationType, final Map map); @Override CriteriaBuilder getCriteriaBuilder(); @Override boolean isOpen(); @Override Cache getCache(); @Override PersistenceUnitUtil getPersistenceUnitUtil(); @Override void addNamedQuery(final String name, final Query query); @Override T unwrap(final Class<T> cls); @Override void addNamedEntityGraph(final String graphName, final EntityGraph<T> entityGraph); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetCriteriaBuilder() { emf.getCriteriaBuilder(); }
### Question: MinijaxEntityManagerFactory implements javax.persistence.EntityManagerFactory, AutoCloseable { @Override public boolean isOpen() { throw new UnsupportedOperationException(); } @SuppressWarnings({ "unchecked", "rawtypes" }) MinijaxEntityManagerFactory(final MinijaxPersistenceUnitInfo unitInfo, final Map<String, Object> properties); MinijaxPersistenceUnitInfo getPersistenceUnitInfo(); @Override MinijaxMetamodel getMetamodel(); @Override Map<String, Object> getProperties(); @Override MinijaxEntityManager createEntityManager(); @Override void close(); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final Map map); @Override EntityManager createEntityManager(final SynchronizationType synchronizationType); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final SynchronizationType synchronizationType, final Map map); @Override CriteriaBuilder getCriteriaBuilder(); @Override boolean isOpen(); @Override Cache getCache(); @Override PersistenceUnitUtil getPersistenceUnitUtil(); @Override void addNamedQuery(final String name, final Query query); @Override T unwrap(final Class<T> cls); @Override void addNamedEntityGraph(final String graphName, final EntityGraph<T> entityGraph); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testIsOpen() { emf.isOpen(); }
### Question: MinijaxEntityManagerFactory implements javax.persistence.EntityManagerFactory, AutoCloseable { @Override public Cache getCache() { throw new UnsupportedOperationException(); } @SuppressWarnings({ "unchecked", "rawtypes" }) MinijaxEntityManagerFactory(final MinijaxPersistenceUnitInfo unitInfo, final Map<String, Object> properties); MinijaxPersistenceUnitInfo getPersistenceUnitInfo(); @Override MinijaxMetamodel getMetamodel(); @Override Map<String, Object> getProperties(); @Override MinijaxEntityManager createEntityManager(); @Override void close(); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final Map map); @Override EntityManager createEntityManager(final SynchronizationType synchronizationType); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final SynchronizationType synchronizationType, final Map map); @Override CriteriaBuilder getCriteriaBuilder(); @Override boolean isOpen(); @Override Cache getCache(); @Override PersistenceUnitUtil getPersistenceUnitUtil(); @Override void addNamedQuery(final String name, final Query query); @Override T unwrap(final Class<T> cls); @Override void addNamedEntityGraph(final String graphName, final EntityGraph<T> entityGraph); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetCache() { emf.getCache(); }
### Question: MinijaxEntityManagerFactory implements javax.persistence.EntityManagerFactory, AutoCloseable { @Override public PersistenceUnitUtil getPersistenceUnitUtil() { throw new UnsupportedOperationException(); } @SuppressWarnings({ "unchecked", "rawtypes" }) MinijaxEntityManagerFactory(final MinijaxPersistenceUnitInfo unitInfo, final Map<String, Object> properties); MinijaxPersistenceUnitInfo getPersistenceUnitInfo(); @Override MinijaxMetamodel getMetamodel(); @Override Map<String, Object> getProperties(); @Override MinijaxEntityManager createEntityManager(); @Override void close(); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final Map map); @Override EntityManager createEntityManager(final SynchronizationType synchronizationType); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final SynchronizationType synchronizationType, final Map map); @Override CriteriaBuilder getCriteriaBuilder(); @Override boolean isOpen(); @Override Cache getCache(); @Override PersistenceUnitUtil getPersistenceUnitUtil(); @Override void addNamedQuery(final String name, final Query query); @Override T unwrap(final Class<T> cls); @Override void addNamedEntityGraph(final String graphName, final EntityGraph<T> entityGraph); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetPersistenceUnitUtil() { emf.getPersistenceUnitUtil(); }
### Question: MinijaxEntityManagerFactory implements javax.persistence.EntityManagerFactory, AutoCloseable { @Override public void addNamedQuery(final String name, final Query query) { throw new UnsupportedOperationException(); } @SuppressWarnings({ "unchecked", "rawtypes" }) MinijaxEntityManagerFactory(final MinijaxPersistenceUnitInfo unitInfo, final Map<String, Object> properties); MinijaxPersistenceUnitInfo getPersistenceUnitInfo(); @Override MinijaxMetamodel getMetamodel(); @Override Map<String, Object> getProperties(); @Override MinijaxEntityManager createEntityManager(); @Override void close(); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final Map map); @Override EntityManager createEntityManager(final SynchronizationType synchronizationType); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final SynchronizationType synchronizationType, final Map map); @Override CriteriaBuilder getCriteriaBuilder(); @Override boolean isOpen(); @Override Cache getCache(); @Override PersistenceUnitUtil getPersistenceUnitUtil(); @Override void addNamedQuery(final String name, final Query query); @Override T unwrap(final Class<T> cls); @Override void addNamedEntityGraph(final String graphName, final EntityGraph<T> entityGraph); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testaddNamedQuery() { emf.addNamedQuery(null, null); }
### Question: MinijaxEntityManagerFactory implements javax.persistence.EntityManagerFactory, AutoCloseable { @Override public <T> T unwrap(final Class<T> cls) { throw new UnsupportedOperationException(); } @SuppressWarnings({ "unchecked", "rawtypes" }) MinijaxEntityManagerFactory(final MinijaxPersistenceUnitInfo unitInfo, final Map<String, Object> properties); MinijaxPersistenceUnitInfo getPersistenceUnitInfo(); @Override MinijaxMetamodel getMetamodel(); @Override Map<String, Object> getProperties(); @Override MinijaxEntityManager createEntityManager(); @Override void close(); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final Map map); @Override EntityManager createEntityManager(final SynchronizationType synchronizationType); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final SynchronizationType synchronizationType, final Map map); @Override CriteriaBuilder getCriteriaBuilder(); @Override boolean isOpen(); @Override Cache getCache(); @Override PersistenceUnitUtil getPersistenceUnitUtil(); @Override void addNamedQuery(final String name, final Query query); @Override T unwrap(final Class<T> cls); @Override void addNamedEntityGraph(final String graphName, final EntityGraph<T> entityGraph); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testUnwrap() { emf.unwrap(null); }
### Question: MinijaxEntityManagerFactory implements javax.persistence.EntityManagerFactory, AutoCloseable { @Override public <T> void addNamedEntityGraph(final String graphName, final EntityGraph<T> entityGraph) { throw new UnsupportedOperationException(); } @SuppressWarnings({ "unchecked", "rawtypes" }) MinijaxEntityManagerFactory(final MinijaxPersistenceUnitInfo unitInfo, final Map<String, Object> properties); MinijaxPersistenceUnitInfo getPersistenceUnitInfo(); @Override MinijaxMetamodel getMetamodel(); @Override Map<String, Object> getProperties(); @Override MinijaxEntityManager createEntityManager(); @Override void close(); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final Map map); @Override EntityManager createEntityManager(final SynchronizationType synchronizationType); @Override @SuppressWarnings("rawtypes") EntityManager createEntityManager(final SynchronizationType synchronizationType, final Map map); @Override CriteriaBuilder getCriteriaBuilder(); @Override boolean isOpen(); @Override Cache getCache(); @Override PersistenceUnitUtil getPersistenceUnitUtil(); @Override void addNamedQuery(final String name, final Query query); @Override T unwrap(final Class<T> cls); @Override void addNamedEntityGraph(final String graphName, final EntityGraph<T> entityGraph); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testaddNamedEntityGraph() { emf.addNamedEntityGraph(null, null); }
### Question: ServerInitializer extends ChannelInitializer<SocketChannel> { @Override public void initChannel(final SocketChannel ch) { ch.pipeline() .addLast("encoder", new HttpResponseEncoder()) .addLast("decoder", new HttpRequestDecoder(4096, 8192, 8192, false)) .addLast("aggregator", new HttpObjectAggregator(1048576)) .addLast("handler", new ServerHandler(minijax, service)); } ServerInitializer(final Minijax minijax, final ScheduledExecutorService service); @Override void initChannel(final SocketChannel ch); }### Answer: @Test public void testPipeline() throws Exception { final Minijax minijax = new Minijax(); final ScheduledExecutorService executor = mock(ScheduledExecutorService.class); final ChannelPipeline pipeline = mock(ChannelPipeline.class); when(pipeline.addLast(anyString(), any())).thenReturn(pipeline); final SocketChannel ch = mock(SocketChannel.class); when(ch.pipeline()).thenReturn(pipeline); final ServerInitializer initializer = new ServerInitializer(minijax, executor); initializer.initChannel(ch); final ArgumentCaptor<ChannelHandler> argument = ArgumentCaptor.forClass(ChannelHandler.class); verify(pipeline, times(4)).addLast(anyString(), argument.capture()); final List<ChannelHandler> handlers = argument.getAllValues(); assertEquals(HttpResponseEncoder.class, handlers.get(0).getClass()); assertEquals(HttpRequestDecoder.class, handlers.get(1).getClass()); assertEquals(HttpObjectAggregator.class, handlers.get(2).getClass()); assertEquals(ServerHandler.class, handlers.get(3).getClass()); }
### Question: LazyList implements List<E> { @Override public boolean isEmpty() { return getData().isEmpty(); } LazyList(final MinijaxBaseTypedQuery<E> query); @Override boolean isEmpty(); @Override boolean contains(final Object o); @Override Iterator<E> iterator(); @Override boolean add(final E e); @Override boolean containsAll(final Collection<?> c); @Override boolean addAll(final Collection<? extends E> c); @Override boolean addAll(final int index, final Collection<? extends E> c); @Override void clear(); @Override boolean equals(final Object o); @Override int hashCode(); @Override E get(final int index); @Override void add(final int index, final E element); @Override void forEach(final Consumer<? super E> arg0); @Override int indexOf(final Object o); @Override int lastIndexOf(final Object o); @Override ListIterator<E> listIterator(); @Override ListIterator<E> listIterator(final int index); @Override Stream<E> parallelStream(); @Override int size(); @Override boolean remove(final Object o); @Override boolean removeAll(final Collection<?> c); @Override boolean retainAll(final Collection<?> c); @Override E remove(final int index); @Override boolean removeIf(final Predicate<? super E> arg0); @Override Object[] toArray(); @Override T[] toArray(final T[] a); @Override void replaceAll(final UnaryOperator<E> operator); @Override void sort(final Comparator<? super E> c); @Override E set(final int index, final E element); @Override Spliterator<E> spliterator(); @Override Stream<E> stream(); @Override List<E> subList(final int fromIndex, final int toIndex); }### Answer: @Test public void testIsEmpty() { final LazyList<String> list1 = new LazyList<>(new MockQuery<>()); assertTrue(list1.isEmpty()); final LazyList<String> list2 = new LazyList<>(new MockQuery<>("foo")); assertFalse(list2.isEmpty()); }
### Question: LazyList implements List<E> { @Override public boolean contains(final Object o) { return getData().contains(o); } LazyList(final MinijaxBaseTypedQuery<E> query); @Override boolean isEmpty(); @Override boolean contains(final Object o); @Override Iterator<E> iterator(); @Override boolean add(final E e); @Override boolean containsAll(final Collection<?> c); @Override boolean addAll(final Collection<? extends E> c); @Override boolean addAll(final int index, final Collection<? extends E> c); @Override void clear(); @Override boolean equals(final Object o); @Override int hashCode(); @Override E get(final int index); @Override void add(final int index, final E element); @Override void forEach(final Consumer<? super E> arg0); @Override int indexOf(final Object o); @Override int lastIndexOf(final Object o); @Override ListIterator<E> listIterator(); @Override ListIterator<E> listIterator(final int index); @Override Stream<E> parallelStream(); @Override int size(); @Override boolean remove(final Object o); @Override boolean removeAll(final Collection<?> c); @Override boolean retainAll(final Collection<?> c); @Override E remove(final int index); @Override boolean removeIf(final Predicate<? super E> arg0); @Override Object[] toArray(); @Override T[] toArray(final T[] a); @Override void replaceAll(final UnaryOperator<E> operator); @Override void sort(final Comparator<? super E> c); @Override E set(final int index, final E element); @Override Spliterator<E> spliterator(); @Override Stream<E> stream(); @Override List<E> subList(final int fromIndex, final int toIndex); }### Answer: @Test public void testContains() { final LazyList<String> list = new LazyList<>(new MockQuery<>("foo")); assertTrue(list.contains("foo")); assertFalse(list.contains("bar")); }
### Question: LazyList implements List<E> { @Override public boolean containsAll(final Collection<?> c) { return getData().containsAll(c); } LazyList(final MinijaxBaseTypedQuery<E> query); @Override boolean isEmpty(); @Override boolean contains(final Object o); @Override Iterator<E> iterator(); @Override boolean add(final E e); @Override boolean containsAll(final Collection<?> c); @Override boolean addAll(final Collection<? extends E> c); @Override boolean addAll(final int index, final Collection<? extends E> c); @Override void clear(); @Override boolean equals(final Object o); @Override int hashCode(); @Override E get(final int index); @Override void add(final int index, final E element); @Override void forEach(final Consumer<? super E> arg0); @Override int indexOf(final Object o); @Override int lastIndexOf(final Object o); @Override ListIterator<E> listIterator(); @Override ListIterator<E> listIterator(final int index); @Override Stream<E> parallelStream(); @Override int size(); @Override boolean remove(final Object o); @Override boolean removeAll(final Collection<?> c); @Override boolean retainAll(final Collection<?> c); @Override E remove(final int index); @Override boolean removeIf(final Predicate<? super E> arg0); @Override Object[] toArray(); @Override T[] toArray(final T[] a); @Override void replaceAll(final UnaryOperator<E> operator); @Override void sort(final Comparator<? super E> c); @Override E set(final int index, final E element); @Override Spliterator<E> spliterator(); @Override Stream<E> stream(); @Override List<E> subList(final int fromIndex, final int toIndex); }### Answer: @Test public void testContainsAll() { final LazyList<String> list = new LazyList<>(new MockQuery<>("foo", "bar")); assertTrue(list.containsAll(Arrays.asList("foo", "bar"))); assertFalse(list.containsAll(Arrays.asList("foo", "bar", "baz"))); }
### Question: LazyList implements List<E> { @Override public Iterator<E> iterator() { return getData().iterator(); } LazyList(final MinijaxBaseTypedQuery<E> query); @Override boolean isEmpty(); @Override boolean contains(final Object o); @Override Iterator<E> iterator(); @Override boolean add(final E e); @Override boolean containsAll(final Collection<?> c); @Override boolean addAll(final Collection<? extends E> c); @Override boolean addAll(final int index, final Collection<? extends E> c); @Override void clear(); @Override boolean equals(final Object o); @Override int hashCode(); @Override E get(final int index); @Override void add(final int index, final E element); @Override void forEach(final Consumer<? super E> arg0); @Override int indexOf(final Object o); @Override int lastIndexOf(final Object o); @Override ListIterator<E> listIterator(); @Override ListIterator<E> listIterator(final int index); @Override Stream<E> parallelStream(); @Override int size(); @Override boolean remove(final Object o); @Override boolean removeAll(final Collection<?> c); @Override boolean retainAll(final Collection<?> c); @Override E remove(final int index); @Override boolean removeIf(final Predicate<? super E> arg0); @Override Object[] toArray(); @Override T[] toArray(final T[] a); @Override void replaceAll(final UnaryOperator<E> operator); @Override void sort(final Comparator<? super E> c); @Override E set(final int index, final E element); @Override Spliterator<E> spliterator(); @Override Stream<E> stream(); @Override List<E> subList(final int fromIndex, final int toIndex); }### Answer: @Test public void testIterator() { final LazyList<String> list = new LazyList<>(new MockQuery<>("foo")); final Iterator<String> iter = list.iterator(); assertTrue(iter.hasNext()); assertEquals("foo", iter.next()); assertFalse(iter.hasNext()); }
### Question: LazyList implements List<E> { @Override public boolean add(final E e) { return getData().add(e); } LazyList(final MinijaxBaseTypedQuery<E> query); @Override boolean isEmpty(); @Override boolean contains(final Object o); @Override Iterator<E> iterator(); @Override boolean add(final E e); @Override boolean containsAll(final Collection<?> c); @Override boolean addAll(final Collection<? extends E> c); @Override boolean addAll(final int index, final Collection<? extends E> c); @Override void clear(); @Override boolean equals(final Object o); @Override int hashCode(); @Override E get(final int index); @Override void add(final int index, final E element); @Override void forEach(final Consumer<? super E> arg0); @Override int indexOf(final Object o); @Override int lastIndexOf(final Object o); @Override ListIterator<E> listIterator(); @Override ListIterator<E> listIterator(final int index); @Override Stream<E> parallelStream(); @Override int size(); @Override boolean remove(final Object o); @Override boolean removeAll(final Collection<?> c); @Override boolean retainAll(final Collection<?> c); @Override E remove(final int index); @Override boolean removeIf(final Predicate<? super E> arg0); @Override Object[] toArray(); @Override T[] toArray(final T[] a); @Override void replaceAll(final UnaryOperator<E> operator); @Override void sort(final Comparator<? super E> c); @Override E set(final int index, final E element); @Override Spliterator<E> spliterator(); @Override Stream<E> stream(); @Override List<E> subList(final int fromIndex, final int toIndex); }### Answer: @Test public void testAdd() { final LazyList<String> list = new LazyList<>(new MockQuery<>("foo")); assertFalse(list.contains("bar")); list.add("bar"); assertTrue(list.contains("bar")); }
### Question: LazyList implements List<E> { @Override public boolean addAll(final Collection<? extends E> c) { return getData().addAll(c); } LazyList(final MinijaxBaseTypedQuery<E> query); @Override boolean isEmpty(); @Override boolean contains(final Object o); @Override Iterator<E> iterator(); @Override boolean add(final E e); @Override boolean containsAll(final Collection<?> c); @Override boolean addAll(final Collection<? extends E> c); @Override boolean addAll(final int index, final Collection<? extends E> c); @Override void clear(); @Override boolean equals(final Object o); @Override int hashCode(); @Override E get(final int index); @Override void add(final int index, final E element); @Override void forEach(final Consumer<? super E> arg0); @Override int indexOf(final Object o); @Override int lastIndexOf(final Object o); @Override ListIterator<E> listIterator(); @Override ListIterator<E> listIterator(final int index); @Override Stream<E> parallelStream(); @Override int size(); @Override boolean remove(final Object o); @Override boolean removeAll(final Collection<?> c); @Override boolean retainAll(final Collection<?> c); @Override E remove(final int index); @Override boolean removeIf(final Predicate<? super E> arg0); @Override Object[] toArray(); @Override T[] toArray(final T[] a); @Override void replaceAll(final UnaryOperator<E> operator); @Override void sort(final Comparator<? super E> c); @Override E set(final int index, final E element); @Override Spliterator<E> spliterator(); @Override Stream<E> stream(); @Override List<E> subList(final int fromIndex, final int toIndex); }### Answer: @Test public void testAddAll() { final LazyList<String> list = new LazyList<>(new MockQuery<>("foo")); assertFalse(list.contains("bar")); list.addAll(Arrays.asList("bar", "baz")); assertEquals(Arrays.asList("foo", "bar", "baz"), list); }
### Question: LazyList implements List<E> { @Override public void clear() { getData().clear(); } LazyList(final MinijaxBaseTypedQuery<E> query); @Override boolean isEmpty(); @Override boolean contains(final Object o); @Override Iterator<E> iterator(); @Override boolean add(final E e); @Override boolean containsAll(final Collection<?> c); @Override boolean addAll(final Collection<? extends E> c); @Override boolean addAll(final int index, final Collection<? extends E> c); @Override void clear(); @Override boolean equals(final Object o); @Override int hashCode(); @Override E get(final int index); @Override void add(final int index, final E element); @Override void forEach(final Consumer<? super E> arg0); @Override int indexOf(final Object o); @Override int lastIndexOf(final Object o); @Override ListIterator<E> listIterator(); @Override ListIterator<E> listIterator(final int index); @Override Stream<E> parallelStream(); @Override int size(); @Override boolean remove(final Object o); @Override boolean removeAll(final Collection<?> c); @Override boolean retainAll(final Collection<?> c); @Override E remove(final int index); @Override boolean removeIf(final Predicate<? super E> arg0); @Override Object[] toArray(); @Override T[] toArray(final T[] a); @Override void replaceAll(final UnaryOperator<E> operator); @Override void sort(final Comparator<? super E> c); @Override E set(final int index, final E element); @Override Spliterator<E> spliterator(); @Override Stream<E> stream(); @Override List<E> subList(final int fromIndex, final int toIndex); }### Answer: @Test public void testClear() { final LazyList<String> list = new LazyList<>(new MockQuery<>("foo")); assertTrue(list.contains("foo")); list.clear(); assertFalse(list.contains("foo")); }
### Question: ServerHandler extends ChannelInboundHandlerAdapter { @Override public void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause) throws Exception { ctx.close(); } ServerHandler(final Minijax minijax, final ScheduledExecutorService service); @Override void channelRead(final ChannelHandlerContext ctx, final Object msg); @Override void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause); @Override void channelReadComplete(final ChannelHandlerContext ctx); }### Answer: @Test public void testExceptionCaught() throws Exception { final Minijax minijax = new Minijax(); final ScheduledExecutorService executor = mock(ScheduledExecutorService.class); final ServerHandler handler = new ServerHandler(minijax, executor); final ChannelHandlerContext ctx = mock(ChannelHandlerContext.class); handler.exceptionCaught(ctx, null); verify(ctx).close(); }
### Question: ServerHandler extends ChannelInboundHandlerAdapter { @Override public void channelReadComplete(final ChannelHandlerContext ctx) throws Exception { ctx.flush(); } ServerHandler(final Minijax minijax, final ScheduledExecutorService service); @Override void channelRead(final ChannelHandlerContext ctx, final Object msg); @Override void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause); @Override void channelReadComplete(final ChannelHandlerContext ctx); }### Answer: @Test public void testChannelReadComplete() throws Exception { final Minijax minijax = new Minijax(); final ScheduledExecutorService executor = mock(ScheduledExecutorService.class); final ServerHandler handler = new ServerHandler(minijax, executor); final ChannelHandlerContext ctx = mock(ChannelHandlerContext.class); handler.channelReadComplete(ctx); verify(ctx).flush(); }
### Question: MinijaxServlet extends HttpServlet { @Override public void init() throws ServletException { throw new ServletException("Missing init parameter \"javax.ws.rs.Application\""); } @Override void init(); @Override @SuppressWarnings("rawtypes") void init(final ServletConfig config); }### Answer: @Test(expected = ServletException.class) public void testInit() throws ServletException { final MinijaxServlet servlet = new MinijaxServlet(); servlet.init(); } @Test(expected = ServletException.class) public void testInitNullParam() throws ServletException { final MinijaxServlet servlet = new MinijaxServlet(); servlet.init(new TestConfig(null)); } @Test(expected = ServletException.class) public void testInitEmptyParam() throws ServletException { final MinijaxServlet servlet = new MinijaxServlet(); servlet.init(new TestConfig("")); } @Test(expected = ServletException.class) public void testInitNotFoundParam() throws ServletException { final MinijaxServlet servlet = new MinijaxServlet(); servlet.init(new TestConfig("com.doesnotexist.Foo")); } @Test public void testInitParamSuccess() throws ServletException { final MinijaxServlet servlet = new MinijaxServlet(); servlet.init(new TestConfig("org.minijax.servlet.MinijaxServletTest$TestApp")); }
### Question: HelloResource { @GET public String hello() { return "Hello world!"; } @GET String hello(); }### Answer: @Test public void testHello() { assertEquals("Hello world!", target("/").request().get(String.class)); }
### Question: MinijaxServletHttpHeaders extends MinijaxHttpHeaders { @Override public String getHeaderString(final String name) { return request.getHeader(name); } MinijaxServletHttpHeaders(final HttpServletRequest request); @Override List<String> getRequestHeader(final String name); @Override String getHeaderString(final String name); @Override MultivaluedMap<String, String> getRequestHeaders(); @Override Map<String, Cookie> getCookies(); }### Answer: @Test public void testBasic() throws Exception { final HttpServletRequest request = mock(HttpServletRequest.class); when(request.getHeader(eq("Content-Type"))).thenReturn("text/plain"); final MinijaxServletHttpHeaders httpHeaders = new MinijaxServletHttpHeaders(request); assertEquals("text/plain", httpHeaders.getHeaderString("Content-Type")); }
### Question: MinijaxPersistenceProvider implements javax.persistence.spi.PersistenceProvider { @Override @SuppressWarnings({ "rawtypes", "unchecked" }) public MinijaxEntityManagerFactory createEntityManagerFactory(final String emName, final Map map) { final MinijaxPersistenceUnitInfo unit = persistenceFile.getPersistenceUnit(emName); if (unit == null) { throw new PersistenceException("Persistence unit not found (\"" + emName + "\")"); } return new MinijaxEntityManagerFactory(unit, map); } MinijaxPersistenceProvider(); @Override @SuppressWarnings({ "rawtypes", "unchecked" }) MinijaxEntityManagerFactory createEntityManagerFactory(final String emName, final Map map); @Override @SuppressWarnings({ "rawtypes", "unchecked" }) MinijaxEntityManagerFactory createContainerEntityManagerFactory(final PersistenceUnitInfo info, final Map map); @Override @SuppressWarnings("rawtypes") void generateSchema(final PersistenceUnitInfo info, final Map map); @Override @SuppressWarnings("rawtypes") boolean generateSchema(final String persistenceUnitName, final Map map); @Override ProviderUtil getProviderUtil(); }### Answer: @Test public void testCreateEntityManagerFactory() { final MinijaxPersistenceProvider provider = new MinijaxPersistenceProvider(); provider.createEntityManagerFactory("testdb", new HashMap<>()); }
### Question: MinijaxPersistenceProvider implements javax.persistence.spi.PersistenceProvider { @Override @SuppressWarnings({ "rawtypes", "unchecked" }) public MinijaxEntityManagerFactory createContainerEntityManagerFactory(final PersistenceUnitInfo info, final Map map) { return new MinijaxEntityManagerFactory((MinijaxPersistenceUnitInfo) info, map); } MinijaxPersistenceProvider(); @Override @SuppressWarnings({ "rawtypes", "unchecked" }) MinijaxEntityManagerFactory createEntityManagerFactory(final String emName, final Map map); @Override @SuppressWarnings({ "rawtypes", "unchecked" }) MinijaxEntityManagerFactory createContainerEntityManagerFactory(final PersistenceUnitInfo info, final Map map); @Override @SuppressWarnings("rawtypes") void generateSchema(final PersistenceUnitInfo info, final Map map); @Override @SuppressWarnings("rawtypes") boolean generateSchema(final String persistenceUnitName, final Map map); @Override ProviderUtil getProviderUtil(); }### Answer: @Test public void testCreateContainerEntityManagerFactory() { final Map<String, String> props = new HashMap<>(); props.put("javax.persistence.jdbc.driver", "org.h2.jdbcx.JdbcDataSource"); props.put("javax.persistence.jdbc.url", "jdbc:h2:mem:"); final MinijaxPersistenceProvider provider = new MinijaxPersistenceProvider(); provider.createContainerEntityManagerFactory(new MinijaxPersistenceUnitInfo("testdb", ""), props); }
### Question: MinijaxPersistenceProvider implements javax.persistence.spi.PersistenceProvider { @Override @SuppressWarnings("rawtypes") public void generateSchema(final PersistenceUnitInfo info, final Map map) { throw new UnsupportedOperationException(); } MinijaxPersistenceProvider(); @Override @SuppressWarnings({ "rawtypes", "unchecked" }) MinijaxEntityManagerFactory createEntityManagerFactory(final String emName, final Map map); @Override @SuppressWarnings({ "rawtypes", "unchecked" }) MinijaxEntityManagerFactory createContainerEntityManagerFactory(final PersistenceUnitInfo info, final Map map); @Override @SuppressWarnings("rawtypes") void generateSchema(final PersistenceUnitInfo info, final Map map); @Override @SuppressWarnings("rawtypes") boolean generateSchema(final String persistenceUnitName, final Map map); @Override ProviderUtil getProviderUtil(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGenerateSchema1() { final MinijaxPersistenceProvider provider = new MinijaxPersistenceProvider(); provider.generateSchema("", null); } @Test(expected = UnsupportedOperationException.class) public void testGenerateSchema2() { final MinijaxPersistenceProvider provider = new MinijaxPersistenceProvider(); provider.generateSchema((PersistenceUnitInfo) null, null); }
### Question: MinijaxPersistenceProvider implements javax.persistence.spi.PersistenceProvider { @Override public ProviderUtil getProviderUtil() { throw new UnsupportedOperationException(); } MinijaxPersistenceProvider(); @Override @SuppressWarnings({ "rawtypes", "unchecked" }) MinijaxEntityManagerFactory createEntityManagerFactory(final String emName, final Map map); @Override @SuppressWarnings({ "rawtypes", "unchecked" }) MinijaxEntityManagerFactory createContainerEntityManagerFactory(final PersistenceUnitInfo info, final Map map); @Override @SuppressWarnings("rawtypes") void generateSchema(final PersistenceUnitInfo info, final Map map); @Override @SuppressWarnings("rawtypes") boolean generateSchema(final String persistenceUnitName, final Map map); @Override ProviderUtil getProviderUtil(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetProviderUtil() { final MinijaxPersistenceProvider provider = new MinijaxPersistenceProvider(); provider.getProviderUtil(); }
### Question: MinijaxServletHttpHeaders extends MinijaxHttpHeaders { @Override public Map<String, Cookie> getCookies() { if (cookies == null) { cookies = new HashMap<>(); final javax.servlet.http.Cookie[] servletCookies = request.getCookies(); for (int i = 0; i < servletCookies.length; i++) { final String name = servletCookies[i].getName(); final String value = servletCookies[i].getValue(); cookies.put(name, new Cookie(name, value)); } } return cookies; } MinijaxServletHttpHeaders(final HttpServletRequest request); @Override List<String> getRequestHeader(final String name); @Override String getHeaderString(final String name); @Override MultivaluedMap<String, String> getRequestHeaders(); @Override Map<String, Cookie> getCookies(); }### Answer: @Test public void testCookies() throws Exception { final javax.servlet.http.Cookie[] servletCookies = new javax.servlet.http.Cookie[] { new javax.servlet.http.Cookie("k", "v") }; final HttpServletRequest request = mock(HttpServletRequest.class); when(request.getCookies()).thenReturn(servletCookies); final MinijaxServletHttpHeaders httpHeaders = new MinijaxServletHttpHeaders(request); final Map<String, Cookie> cookies = httpHeaders.getCookies(); assertNotNull(cookies); assertEquals(1, cookies.size()); assertEquals("v", cookies.get("k").getValue()); assertEquals(cookies, httpHeaders.getCookies()); }
### Question: Worker implements Runnable { public void setNextWorker(final Worker nextWorker) { if (this.nextWorker != null) { throw new IllegalStateException("nextWorker should only be set once"); } this.nextWorker = nextWorker; } Worker(final Minijax minijax, final SelectorProvider selectorProvider); boolean isRunning(); void setRunning(final boolean running); Worker getNextWorker(); void setNextWorker(final Worker nextWorker); void accept(final SocketChannel socketChannel); @Override void run(); }### Answer: @Test(expected = IllegalStateException.class) public void testSetNextWorker() throws IOException { final Worker worker = new Worker(null, new MockSelectorProvider()); worker.setNextWorker(worker); worker.setNextWorker(worker); }
### Question: MediaTypeUtils { public static List<MediaType> parseMediaTypes(final Consumes consumes) { return consumes == null ? Collections.emptyList() : parseMediaTypes(consumes.value()); } MediaTypeUtils(); static List<MediaType> parseMediaTypes(final Consumes consumes); static List<MediaType> parseMediaTypes(final Produces produces); static List<MediaType> parseMediaTypes(final String str); }### Answer: @Test public void testParseNullConsumes() { assertTrue(MediaTypeUtils.parseMediaTypes((Consumes) null).isEmpty()); } @Test public void testParseConsumes() { assertEquals( APPLICATION_FORM_URLENCODED_TYPE, MediaTypeUtils.parseMediaTypes(MediaTypeUtilsTest.class.getAnnotation(Consumes.class)).get(0)); } @Test public void testParseNullProduces() { assertTrue(MediaTypeUtils.parseMediaTypes((Produces) null).isEmpty()); } @Test public void testParseProduces() { assertEquals( TEXT_HTML_TYPE, MediaTypeUtils.parseMediaTypes(MediaTypeUtilsTest.class.getAnnotation(Produces.class)).get(0)); }
### Question: ClassPathScanner { public static Set<Class<?>> scan(final String packageName) throws IOException { return scan(packageName, Thread.currentThread().getContextClassLoader()); } static Set<Class<?>> scan(final String packageName); static Set<Class<?>> scan(final String packageName, final ClassLoader cld); }### Answer: @Test public void testScanner() throws IOException { final Set<Class<?>> result = ClassPathScanner.scan("org.minijax"); assertNotNull(result); assertFalse(result.isEmpty()); } @Test public void testJarScanner() throws IOException { final URLClassLoader loader = new URLClassLoader(new URL[] { new URL("jar:file:src/test/resources/dummy.jar!/") }); final Set<Class<?>> result = ClassPathScanner.scan("com.example", loader); assertNotNull(result); assertEquals(2, result.size()); } @Test(expected = IllegalArgumentException.class) public void testUnknownProtocol() throws IOException { final URL url = new URL("http: final Vector<URL> urlList = new Vector<>(); urlList.add(url); final ClassLoader mockLoader = new ClassLoader() { @Override public Enumeration<URL> getResources(final String name) throws IOException { return urlList.elements(); } }; ClassPathScanner.scan("com.example", mockLoader); }
### Question: HelloApplication extends Application { @Override public Set<Class<?>> getClasses() { return new HashSet<>(Arrays.asList( HelloResource.class, PostResource.class, ShoutResource.class)); } @Override Set<Class<?>> getClasses(); }### Answer: @Test public void testApp() { final HelloApplication app = new HelloApplication(); final Set<Class<?>> c = app.getClasses(); assertTrue(c.contains(HelloResource.class)); assertTrue(c.contains(PostResource.class)); assertTrue(c.contains(ShoutResource.class)); }
### Question: NetworkUtils { public static String getIpAddress(final Enumeration<NetworkInterface> nis) { while (nis.hasMoreElements()) { final NetworkInterface ni = nis.nextElement(); final String address = getIpAddress(ni); if (address != null && !address.startsWith("127.") && !address.startsWith("169.")) { return address; } } return null; } NetworkUtils(); static String getIpAddress(final Enumeration<NetworkInterface> nis); }### Answer: @Test public void testEmptyInterfaces() { final Enumeration<NetworkInterface> nis = enumeration(emptyList()); assertNull(NetworkUtils.getIpAddress(nis)); } @Test public void testLoopbackOnly() { final Enumeration<NetworkInterface> nis = enumeration(singletonList(createInterface("127.0.0.1"))); assertNull(NetworkUtils.getIpAddress(nis)); } @Test public void testLinkLocalOnly() { final Enumeration<NetworkInterface> nis = enumeration(singletonList(createInterface("169.254.172.42"))); assertNull(NetworkUtils.getIpAddress(nis)); } @Test public void testIpv6Only() { final Enumeration<NetworkInterface> nis = enumeration(singletonList(createInterface("2001:0db8:85a3:0000:0000:8a2e:0370:7334"))); assertNull(NetworkUtils.getIpAddress(nis)); } @Test public void testFargate() { final Enumeration<NetworkInterface> nis = enumeration(asList( createInterface("127.0.0.1"), createInterface("169.254.172.42"), createInterface("2001:0db8:85a3:0000:0000:8a2e:0370:7334", "10.0.0.1"))); assertEquals("10.0.0.1", NetworkUtils.getIpAddress(nis)); }
### Question: MinijaxASAdmin { @GET public static String hello() { return "Hello world!"; } @GET static String hello(); static void main(final String[] args); }### Answer: @Test public void testHello() { assertEquals("Hello world!", target("/").request().get(String.class)); }
### Question: JsonMapConverter implements AttributeConverter<Map<String, Object>, String> { @Override @SuppressWarnings("unchecked") public Map<String, Object> convertToEntityAttribute(final String str) { if (str == null \|\| str.isEmpty()) { return null; } try { return Json.getObjectMapper().readValue(str, Map.class); } catch (final IOException ex) { throw new MinijaxException(ex.getMessage(), ex); } } @Override String convertToDatabaseColumn(final Map<String, Object> map); @Override @SuppressWarnings("unchecked") Map<String, Object> convertToEntityAttribute(final String str); }### Answer: @Test public void testEmptyString() { final JsonMapConverter c = new JsonMapConverter(); assertNull(c.convertToEntityAttribute("")); } @Test(expected = MinijaxException.class) public void testInvalidJsonParse() { final JsonMapConverter c = new JsonMapConverter(); c.convertToEntityAttribute("{"); }
### Question: JsonMapConverter implements AttributeConverter<Map<String, Object>, String> { @Override public String convertToDatabaseColumn(final Map<String, Object> map) { if (map == null) { return null; } try { return Json.getObjectMapper().writeValueAsString(map); } catch (final JsonProcessingException ex) { throw new MinijaxException(ex.getMessage(), ex); } } @Override String convertToDatabaseColumn(final Map<String, Object> map); @Override @SuppressWarnings("unchecked") Map<String, Object> convertToEntityAttribute(final String str); }### Answer: @Test(expected = MinijaxException.class) public void testInvalidJsonWrite() { final JsonMapConverter c = new JsonMapConverter(); final Map<String, Object> m1 = new HashMap<>(); m1.put("a", new Object()); c.convertToDatabaseColumn(m1); }
### Question: UrlConverter implements AttributeConverter<URL, String> { @Override public URL convertToEntityAttribute(final String str) { if (str == null) { return null; } try { return new URL(str); } catch (final MalformedURLException ex) { throw new MinijaxException(ex.getMessage(), ex); } } @Override String convertToDatabaseColumn(final URL url); @Override URL convertToEntityAttribute(final String str); }### Answer: @Test(expected = MinijaxException.class) public void testMalformedUrl() throws MalformedURLException { final UrlConverter c = new UrlConverter(); final String str = "! bad url !"; c.convertToEntityAttribute(str); }
### Question: PasswordChangeRequest extends DefaultBaseEntity { public void setCode(final String code) { this.code = code; } UUID getUserId(); void setUser(final SecurityUser user); String getCode(); void setCode(final String code); }### Answer: @Test public void testValidateNullCode() { final PasswordChangeRequest pcr = new PasswordChangeRequest(); pcr.setCode(null); assertEquals(1, validator.validate(pcr).size()); } @Test public void testValidateEmptyCode() { final PasswordChangeRequest pcr = new PasswordChangeRequest(); pcr.setCode(""); assertEquals(2, validator.validate(pcr).size()); } @Test public void testValidateTooShortCode() { final PasswordChangeRequest pcr = new PasswordChangeRequest(); pcr.setCode("01234567890123456789"); assertEquals(2, validator.validate(pcr).size()); }
### Question: UserSession extends DefaultBaseEntity { public void setUser(final SecurityUser user) { userId = user.getId(); this.user = user; } UUID getUserId(); SecurityUser getUser(); void setUser(final SecurityUser user); }### Answer: @Test public void testValidate() { final UserSession s = new UserSession(); s.setUser(new User()); assertTrue(validator.validate(s).isEmpty()); }
### Question: ApiKey extends DefaultBaseEntity { public void setValue(final String value) { this.value = value; } UUID getUserId(); void setUser(final SecurityUser user); String getName(); void setName(final String name); String getValue(); void setValue(final String value); }### Answer: @Test public void testValidateNullCode() { final ApiKey apiKey = new ApiKey(); apiKey.setValue(null); assertEquals(1, validator.validate(apiKey).size()); }
### Question: Security implements SecurityContext { public void requireLogin() { if (!isLoggedIn()) { throw new NotAuthorizedException(Response.status(Status.UNAUTHORIZED).build()); } } @Inject @SuppressWarnings("unchecked") Security( final SecurityDao dao, @Context final Configuration configuration, @HeaderParam(AUTHORIZATION) final String authorization, @CookieParam(COOKIE_NAME) final String cookie); Class<SecurityUser> getUserClass(); @Override @SuppressWarnings("unchecked") T getUserPrincipal(); boolean isLoggedIn(); void requireLogin(); String getSessionToken(); LoginResult login(final String email, final String password); NewCookie loginAs(final SecurityUser candidate); NewCookie logout(); ChangePasswordResult changePassword(final String oldPassword, final String newPassword, final String confirmNewPassword); String forgotPassword(final SecurityUser user); ResetPasswordResult resetPassword(final String resetId, final String newPassword, final String confirmNewPassword); @Override boolean isUserInRole(final String role); @Override boolean isSecure(); @Override String getAuthenticationScheme(); static final int MINIMUM_PASSWORD_LENGTH; static final String COOKIE_NAME; }### Answer: @Test(expected = NotAuthorizedException.class) public void testAnonymousRequireLogin() { final SecurityDao dao = mock(SecurityDao.class); final Configuration config = mock(Configuration.class); final Security<User> security = new Security<>(dao, config, null, null); security.requireLogin(); }
### Question: HelloSsl { @GET @Path("/") public static String hello() { return "Hello world!"; } @GET @Path("/") static String hello(); static void main(final String[] args); }### Answer: @Test public void testHello() { assertEquals("Hello world!", target("/").request().get(String.class)); }
### Question: LiquibaseHelper { static boolean isIgnoredChangeSet(final ChangeSet changeSet) { final List<Change> changes = changeSet.getChanges(); if (changes.size() != 1) { return false; } final Change change = changes.get(0); if (!(change instanceof DropTableChange)) { return false; } return ((DropTableChange) change).getTableName().equals("JGROUPSPING"); } LiquibaseHelper(final Map<String, String> props); LiquibaseHelper( final Map<String, String> props, final ResourceAccessor resourceAccessor, final File resourcesDir, final String masterChangeLogName); File getResourcesDir(); File getMasterChangeLogFile(); void migrate(); File generateMigrations(); }### Answer: @Test public void testNotIgnoreEmptyChangeSet() { final ChangeSet changeSet = new ChangeSet(null); assertFalse(LiquibaseHelper.isIgnoredChangeSet(changeSet)); } @Test public void testNotIgnoreAddColumn() { final AddColumnChange change = new AddColumnChange(); final ChangeSet changeSet = new ChangeSet(null); changeSet.addChange(change); assertFalse(LiquibaseHelper.isIgnoredChangeSet(changeSet)); } @Test public void testNotIgnoreDropOtherTable() { final DropTableChange change = new DropTableChange(); change.setTableName("foo"); final ChangeSet changeSet = new ChangeSet(null); changeSet.addChange(change); assertFalse(LiquibaseHelper.isIgnoredChangeSet(changeSet)); } @Test public void testIgnoreChangeSet() { final DropTableChange change = new DropTableChange(); change.setTableName("JGROUPSPING"); final ChangeSet changeSet = new ChangeSet(null); changeSet.addChange(change); assertTrue(LiquibaseHelper.isIgnoredChangeSet(changeSet)); }
### Question: LiquibaseHelper { static List<ChangeSet> filterChangeSets(final List<ChangeSet> changeSets) { final List<ChangeSet> result = new ArrayList<>(); for (final ChangeSet changeSet : changeSets) { if (!isIgnoredChangeSet(changeSet)) { result.add(changeSet); } } return result; } LiquibaseHelper(final Map<String, String> props); LiquibaseHelper( final Map<String, String> props, final ResourceAccessor resourceAccessor, final File resourcesDir, final String masterChangeLogName); File getResourcesDir(); File getMasterChangeLogFile(); void migrate(); File generateMigrations(); }### Answer: @Test public void testFilterChangeSets() { final DropTableChange c1 = new DropTableChange(); c1.setTableName("foo"); final ChangeSet cs1 = new ChangeSet(null); cs1.addChange(c1); final DropTableChange c2 = new DropTableChange(); c2.setTableName("JGROUPSPING"); final ChangeSet cs2 = new ChangeSet(null); cs2.addChange(c2); final List<ChangeSet> original = Arrays.asList(cs1, cs2); final List<ChangeSet> filtered = LiquibaseHelper.filterChangeSets(original); assertEquals(1, filtered.size()); assertEquals(c1, filtered.get(0).getChanges().get(0)); }
### Question: LiquibaseHelper { static void closeQuietly(final EntityManagerFactory emf) { if (emf != null) { try { emf.close(); } catch (final Exception ex) { LOG.warn("Error closing entity manager factory: {}", ex.getMessage(), ex); } } } LiquibaseHelper(final Map<String, String> props); LiquibaseHelper( final Map<String, String> props, final ResourceAccessor resourceAccessor, final File resourcesDir, final String masterChangeLogName); File getResourcesDir(); File getMasterChangeLogFile(); void migrate(); File generateMigrations(); }### Answer: @Test public void testCloseEntityManagerFactoryNull() { LiquibaseHelper.closeQuietly((EntityManagerFactory) null); } @Test public void testCloseEntityManagerFactoryException() throws Exception { final EntityManagerFactory emf = mock(EntityManagerFactory.class); doThrow(new RuntimeException("Boom")).when(emf).close(); LiquibaseHelper.closeQuietly(emf); verify(emf).close(); } @Test public void testCloseDatabaseNull() { LiquibaseHelper.closeQuietly((Database) null); } @Test public void testCloseDatabaseException() throws Exception { final Database database = mock(Database.class); doThrow(new RuntimeException("Boom")).when(database).close(); LiquibaseHelper.closeQuietly(database); verify(database).close(); }
### Question: UrlUtils { public static String concatUrlPaths(final String base, final String path) { if (base == null && path == null) { return "/"; } String result; if (base == null) { result = path; } else if (path == null) { result = base; } else { result = base + "/" + path; } result = result.replaceAll("/+", "/"); if (result.endsWith("/")) { result = result.substring(0, result.length() - 1); } if (!result.startsWith("/")) { result = "/" + result; } return result; } UrlUtils(); static String concatUrlPaths(final String base, final String path); static Map<String, String> urlDecodeParams(final String str); static MultivaluedMap<String, String> urlDecodeMultivaluedParams(final String str); static String urlEncodeParams(final Map<String, String> params); static String urlEncodeMultivaluedParams(final MultivaluedMap<String, String> params); static String urlEncode(final String str); static String urlDecode(final String str); static String urlEncode(final String str, final boolean ignoreTemplates, final boolean ignoreSlashes); }### Answer: @Test public void testConcatUrls() { assertEquals("/", UrlUtils.concatUrlPaths(null, null)); assertEquals("/", UrlUtils.concatUrlPaths(null, "")); assertEquals("/", UrlUtils.concatUrlPaths("", null)); assertEquals("/", UrlUtils.concatUrlPaths("", "")); assertEquals("/a/b", UrlUtils.concatUrlPaths("a", "b")); assertEquals("/a/b", UrlUtils.concatUrlPaths("/a", "/b")); }
### Question: UrlUtils { public static String urlEncode(final String str) { if (str == null) { return ""; } return new UrlEncoder(str, false, false).encode(); } UrlUtils(); static String concatUrlPaths(final String base, final String path); static Map<String, String> urlDecodeParams(final String str); static MultivaluedMap<String, String> urlDecodeMultivaluedParams(final String str); static String urlEncodeParams(final Map<String, String> params); static String urlEncodeMultivaluedParams(final MultivaluedMap<String, String> params); static String urlEncode(final String str); static String urlDecode(final String str); static String urlEncode(final String str, final boolean ignoreTemplates, final boolean ignoreSlashes); }### Answer: @Test public void testUrlEncodeIgnoreTemplates() { assertEquals("foo", UrlUtils.urlEncode("foo", true, false)); assertEquals("123", UrlUtils.urlEncode("123", true, false)); assertEquals("a%20b", UrlUtils.urlEncode("a b", true, false)); assertEquals("foo{bar}", UrlUtils.urlEncode("foo{bar}", true, false)); assertEquals("foo{bar:[a-z]{1-3}}", UrlUtils.urlEncode("foo{bar:[a-z]{1-3}}", true, false)); assertEquals("%f0%9f%98%81", UrlUtils.urlEncode(new String( new byte[] { (byte) 0xF0, (byte) 0x9F, (byte) 0x98, (byte) 0x81 }, StandardCharsets.UTF_8), true, false)); }
### Question: MultipartUtils { public static InputStream serializeMultipartForm(final Multipart form) throws IOException { try (final ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) { serializeMultipartForm(form, outputStream); return new ByteArrayInputStream(outputStream.toByteArray()); } } MultipartUtils(); static InputStream serializeMultipartForm(final Multipart form); static void serializeMultipartForm(final Multipart form, final OutputStream outputStream); }### Answer: @Test public void testEmpty() throws IOException { final Multipart form = new Multipart(); final InputStream inputStream = MultipartUtils.serializeMultipartForm(form); final Collection<Part> parts = Multipart.read(form.getContentType(), -1, inputStream).getParts(); assertTrue(parts.isEmpty()); } @Test public void testSimple() throws IOException { final Multipart form = new Multipart(); form.param("a", "b"); final InputStream inputStream = MultipartUtils.serializeMultipartForm(form); final List<Part> parts = new ArrayList<>(Multipart.read(form.getContentType(), -1, inputStream).getParts()); assertEquals(1, parts.size()); assertEquals("a", parts.get(0).getName()); assertEquals("b", IOUtils.toString(parts.get(0).getInputStream(), StandardCharsets.UTF_8)); } @Test public void testFileUpload() throws IOException { final Multipart form = new Multipart(); form.param("a", "b"); form.param("myfile", "config.properties", new FileInputStream("src/test/resources/config.properties")); final InputStream inputStream = MultipartUtils.serializeMultipartForm(form); final List<Part> parts = new ArrayList<>(Multipart.read(form.getContentType(), -1, inputStream).getParts()); assertEquals(2, parts.size()); assertEquals("a", parts.get(0).getName()); assertEquals("b", IOUtils.toString(parts.get(0).getInputStream(), StandardCharsets.UTF_8)); assertEquals("myfile", parts.get(1).getName()); assertEquals("a=b\n", IOUtils.toString(parts.get(1).getInputStream(), StandardCharsets.UTF_8)); }
### Question: Owner extends DefaultBaseEntity { @Override public boolean equals(final Object obj) { return EqualsBuilder.reflectionEquals(this, obj); } String getName(); void setName(final String name); String getAddress(); void setAddress(final String address); String getCity(); void setCity(final String city); String getTelephone(); void setTelephone(final String telephone); List<Pet> getPets(); void setPets(final List<Pet> pets); String getUrl(); @Override boolean equals(final Object obj); @Override int hashCode(); }### Answer: @Test public void testEquals() { final Owner o1 = new Owner(); final Owner o2 = new Owner(); final Owner o3 = new Owner(); o2.setId(o1.getId()); assertEquals(o1, o2); assertNotEquals(o1, null); assertNotEquals(o1, new Object()); assertNotEquals(o1, o3); }
### Question: ImplicitTemplateMap extends HashMap<String, Object> { @Override public Object get(final Object key) { Object result = super.get(key); if (result == null) { result = templateValues[index++]; super.put(key.toString(), result); } return result; } ImplicitTemplateMap(final Object[] templateValues); @Override Object get(final Object key); @Override int hashCode(); @Override boolean equals(final Object obj); }### Answer: @Test public void testSimple() { final ImplicitTemplateMap map = new ImplicitTemplateMap(new Object[] {"a", "b"}); assertEquals("a", map.get("foo")); assertEquals("a", map.get("foo")); }
### Question: ImplicitTemplateMap extends HashMap<String, Object> { @Override public boolean equals(final Object obj) { if (!(obj instanceof ImplicitTemplateMap)) { return false; } final ImplicitTemplateMap other = (ImplicitTemplateMap) obj; return super.equals(other) && Arrays.equals(templateValues, other.templateValues); } ImplicitTemplateMap(final Object[] templateValues); @Override Object get(final Object key); @Override int hashCode(); @Override boolean equals(final Object obj); }### Answer: @Test public void testEquals() { final ImplicitTemplateMap m1 = new ImplicitTemplateMap(new Object[] {"a", "b"}); final ImplicitTemplateMap m2 = new ImplicitTemplateMap(new Object[] {"a", "b"}); final ImplicitTemplateMap m3 = new ImplicitTemplateMap(new Object[] {"c", "d"}); final ImplicitTemplateMap m4 = new ImplicitTemplateMap(new Object[] {"c", "d"}); assertEquals(m1, m1); assertEquals(m1.hashCode(), m2.hashCode()); assertEquals(m1, m2); assertEquals(m3, m4); assertNotEquals(m1, m3); assertNotEquals(m1, null); assertNotEquals(m1, new Object()); m4.get("foo"); assertNotEquals(m3, m4); }
### Question: PersistenceContextAnnotationProcessor implements FieldAnnotationProcessor<EntityManager> { @Override @SuppressWarnings("unchecked") public MinijaxProvider<EntityManager> buildProvider( final MinijaxInjectorState state, final Class<EntityManager> type, final Annotation[] annotations) { final PersistenceContext persistenceContext = getPersistenceContextAnnotation(annotations); final EntityManagerFactory emf = factories.get(persistenceContext.name()); if (emf == null) { throw new InjectionException("Persistence context \"" + persistenceContext.name() + "\" not found"); } return new EntityManagerProvider(emf); } PersistenceContextAnnotationProcessor(final Map<String, EntityManagerFactory> factories); @Override @SuppressWarnings("unchecked") MinijaxProvider<EntityManager> buildProvider( final MinijaxInjectorState state, final Class<EntityManager> type, final Annotation[] annotations); }### Answer: @Test public void testSimple() { final Map<String, EntityManagerFactory> factories = createFactories(""); final PersistenceContextAnnotationProcessor p = new PersistenceContextAnnotationProcessor(factories); final PersistenceContext annotation = createAnnotation(""); final Provider<EntityManager> provider = p.buildProvider(null, EntityManager.class, new Annotation[] { annotation }); assertNotNull(provider); } @Test(expected = InjectionException.class) public void testNotFound() { final Map<String, EntityManagerFactory> factories = createFactories("foo", "bar"); final PersistenceContextAnnotationProcessor p = new PersistenceContextAnnotationProcessor(factories); final PersistenceContext annotation = createAnnotation("baz"); p.buildProvider(null, EntityManager.class, new Annotation[] { annotation }); } @Test public void testOtherAnnotations() { final Map<String, EntityManagerFactory> factories = createFactories(""); final PersistenceContextAnnotationProcessor p = new PersistenceContextAnnotationProcessor(factories); final Provider<EntityManager> provider = p.buildProvider(null, EntityManager.class, new Annotation[] { new Deprecated() { @Override public Class<? extends Annotation> annotationType() { return Deprecated.class; }}, createAnnotation(""), }); assertNotNull(provider); }
### Question: PersistenceContextAnnotationProcessor implements FieldAnnotationProcessor<EntityManager> { PersistenceContext getPersistenceContextAnnotation(final Annotation[] annotations) { for (final Annotation annotation : annotations) { if (annotation.annotationType() == PersistenceContext.class) { return (PersistenceContext) annotation; } } throw new InjectionException("Missing @PersistenceContext annotation"); } PersistenceContextAnnotationProcessor(final Map<String, EntityManagerFactory> factories); @Override @SuppressWarnings("unchecked") MinijaxProvider<EntityManager> buildProvider( final MinijaxInjectorState state, final Class<EntityManager> type, final Annotation[] annotations); }### Answer: @Test(expected = InjectionException.class) public void testMissingAnnotation() { final Map<String, EntityManagerFactory> factories = createFactories("foo", "bar"); final PersistenceContextAnnotationProcessor p = new PersistenceContextAnnotationProcessor(factories); p.getPersistenceContextAnnotation(new Annotation[0]); }
### Question: PersistenceUtils { public static List<String> getNames(final String fileName) { try (final InputStream in = PersistenceUtils.class.getClassLoader().getResourceAsStream(fileName)) { if (in == null) { return Collections.emptyList(); } return scanPersistenceXml(in); } catch (final Exception ex) { LOG.warn("Error reading persistence.xml: {}", ex.getMessage(), ex); return Collections.emptyList(); } } PersistenceUtils(); static List<String> getNames(final String fileName); }### Answer: @Test public void testNotFound() { assertEquals(Collections.emptyList(), PersistenceUtils.getNames("not-found.xml")); } @Test public void testNotXml() { assertEquals(Collections.emptyList(), PersistenceUtils.getNames("not-xml.txt")); } @Test public void testOne() { assertEquals(Collections.singletonList("testdb"), PersistenceUtils.getNames("test-persistence1.xml")); } @Test public void testMultiple() { assertEquals(Arrays.asList("test1", "test2"), PersistenceUtils.getNames("test-persistence2.xml")); }
### Question: TodoBackend { @DELETE public Response delete() { posts.clear(); return Response.ok().build(); } @GET Collection<Post> read(); @POST @Consumes(APPLICATION_JSON) Response create(@Context final UriInfo uriInfo, final Post post); @DELETE Response delete(); @GET @Path("/{id}") Post read(@PathParam("id") final int id); @PATCH @Path("/{id}") @Consumes(APPLICATION_JSON) Post update(@PathParam("id") final int id, final Post updated); @DELETE @Path("/{id}") Response delete(@PathParam("id") final int id); static void main(final String[] args); }### Answer: @Test public void testDeletePost() { final Response r1 = target("/").request().post(Entity.entity("{\"title\":\"blah\"}", APPLICATION_JSON)); final Post post = (Post) r1.getEntity(); target(post.url).request().delete(); final Response r3 = target(post.url).request().get(); assertEquals(404, r3.getStatus()); } @Test @SuppressWarnings("rawtypes") public void testDeleteAll() { final Response r1 = target("/").request().delete(); assertNotNull(r1); final Response r2 = target("/").request().get(); assertNotNull(r2); assertTrue(((Collection) r2.getEntity()).isEmpty()); }
### Question: PersistenceFeature implements Feature { @Override public boolean configure(final FeatureContext context) { if (!(context instanceof MinijaxApplicationContext)) { throw new IllegalArgumentException("Minijax PersistenceFeature only compatible with MinijaxApplication"); } final MinijaxApplicationContext app = (MinijaxApplicationContext) context; registerPersistence(app); return true; } @Override boolean configure(final FeatureContext context); void registerPersistence(final MinijaxApplicationContext app); }### Answer: @Test(expected = IllegalArgumentException.class) public void testNotMinijax() { final PersistenceFeature feature = new PersistenceFeature(); feature.configure(mock(FeatureContext.class)); }
### Question: CopyOnWriteMap implements ConcurrentMap<K, V> { @Override public synchronized void putAll(final Map<? extends K, ? extends V> m) { final Map<K, V> newDelegate = new HashMap<>(this.delegate); for (final Entry<? extends K, ? extends V> e : m.entrySet()) { newDelegate.put(e.getKey(), e.getValue()); } this.delegate = newDelegate; } CopyOnWriteMap(); CopyOnWriteMap(final Map<K, V> existing); @Override synchronized V putIfAbsent(final K key, final V value); @Override synchronized boolean remove(final Object key, final Object value); @Override synchronized boolean replace(final K key, final V oldValue, final V newValue); @Override synchronized V replace(final K key, final V value); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(final Object key); @Override boolean containsValue(final Object value); @Override V get(final Object key); @Override synchronized V put(final K key, final V value); @Override synchronized V remove(final Object key); @Override synchronized void putAll(final Map<? extends K, ? extends V> m); @Override synchronized void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); V removeInternal(final Object key); }### Answer: @Test public void testPutAll() { final HashMap<String, String> prev = new HashMap<>(); prev.put("a", "b"); final CopyOnWriteMap<String, String> map = new CopyOnWriteMap<>(); map.putAll(prev); assertEquals("b", map.get("a")); }
### Question: CopyOnWriteMap implements ConcurrentMap<K, V> { @Override public synchronized V putIfAbsent(final K key, final V value) { final Map<K, V> oldDelegate = this.delegate; final V existing = oldDelegate.get(key); if (existing != null) { return existing; } putInternal(key, value); return null; } CopyOnWriteMap(); CopyOnWriteMap(final Map<K, V> existing); @Override synchronized V putIfAbsent(final K key, final V value); @Override synchronized boolean remove(final Object key, final Object value); @Override synchronized boolean replace(final K key, final V oldValue, final V newValue); @Override synchronized V replace(final K key, final V value); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(final Object key); @Override boolean containsValue(final Object value); @Override V get(final Object key); @Override synchronized V put(final K key, final V value); @Override synchronized V remove(final Object key); @Override synchronized void putAll(final Map<? extends K, ? extends V> m); @Override synchronized void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); V removeInternal(final Object key); }### Answer: @Test public void testPutIfAbsent() { final CopyOnWriteMap<String, String> map = new CopyOnWriteMap<>(); map.putIfAbsent("a", "b"); map.putIfAbsent("a", "c"); assertEquals("b", map.get("a")); }
### Question: CopyOnWriteMap implements ConcurrentMap<K, V> { @Override public synchronized boolean remove(final Object key, final Object value) { final Map<K, V> oldDelegate = this.delegate; final V existing = oldDelegate.get(key); if (existing.equals(value)) { removeInternal(key); return true; } return false; } CopyOnWriteMap(); CopyOnWriteMap(final Map<K, V> existing); @Override synchronized V putIfAbsent(final K key, final V value); @Override synchronized boolean remove(final Object key, final Object value); @Override synchronized boolean replace(final K key, final V oldValue, final V newValue); @Override synchronized V replace(final K key, final V value); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(final Object key); @Override boolean containsValue(final Object value); @Override V get(final Object key); @Override synchronized V put(final K key, final V value); @Override synchronized V remove(final Object key); @Override synchronized void putAll(final Map<? extends K, ? extends V> m); @Override synchronized void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); V removeInternal(final Object key); }### Answer: @Test public void testRemove() { final CopyOnWriteMap<String, String> map = new CopyOnWriteMap<>(); map.put("a", "b"); map.remove("a"); assertNull(map.get("a")); }
### Question: CopyOnWriteMap implements ConcurrentMap<K, V> { @Override public synchronized boolean replace(final K key, final V oldValue, final V newValue) { final Map<K, V> oldDelegate = this.delegate; final V existing = oldDelegate.get(key); if (existing.equals(oldValue)) { putInternal(key, newValue); return true; } return false; } CopyOnWriteMap(); CopyOnWriteMap(final Map<K, V> existing); @Override synchronized V putIfAbsent(final K key, final V value); @Override synchronized boolean remove(final Object key, final Object value); @Override synchronized boolean replace(final K key, final V oldValue, final V newValue); @Override synchronized V replace(final K key, final V value); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(final Object key); @Override boolean containsValue(final Object value); @Override V get(final Object key); @Override synchronized V put(final K key, final V value); @Override synchronized V remove(final Object key); @Override synchronized void putAll(final Map<? extends K, ? extends V> m); @Override synchronized void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); V removeInternal(final Object key); }### Answer: @Test public void testReplace() { final CopyOnWriteMap<String, String> map = new CopyOnWriteMap<>(); map.put("a", "b"); assertEquals("b", map.get("a")); map.replace("b", "c"); assertEquals("b", map.get("a")); map.replace("a", "c"); assertEquals("c", map.get("a")); }
### Question: CopyOnWriteMap implements ConcurrentMap<K, V> { @Override public synchronized void clear() { delegate = Collections.emptyMap(); } CopyOnWriteMap(); CopyOnWriteMap(final Map<K, V> existing); @Override synchronized V putIfAbsent(final K key, final V value); @Override synchronized boolean remove(final Object key, final Object value); @Override synchronized boolean replace(final K key, final V oldValue, final V newValue); @Override synchronized V replace(final K key, final V value); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(final Object key); @Override boolean containsValue(final Object value); @Override V get(final Object key); @Override synchronized V put(final K key, final V value); @Override synchronized V remove(final Object key); @Override synchronized void putAll(final Map<? extends K, ? extends V> m); @Override synchronized void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); V removeInternal(final Object key); }### Answer: @Test public void testClear() { final CopyOnWriteMap<String, String> map = new CopyOnWriteMap<>(); map.put("a", "b"); map.clear(); assertNull(map.get("a")); assertTrue(map.isEmpty()); }
### Question: CopyOnWriteMap implements ConcurrentMap<K, V> { @Override public boolean containsKey(final Object key) { return delegate.containsKey(key); } CopyOnWriteMap(); CopyOnWriteMap(final Map<K, V> existing); @Override synchronized V putIfAbsent(final K key, final V value); @Override synchronized boolean remove(final Object key, final Object value); @Override synchronized boolean replace(final K key, final V oldValue, final V newValue); @Override synchronized V replace(final K key, final V value); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(final Object key); @Override boolean containsValue(final Object value); @Override V get(final Object key); @Override synchronized V put(final K key, final V value); @Override synchronized V remove(final Object key); @Override synchronized void putAll(final Map<? extends K, ? extends V> m); @Override synchronized void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); V removeInternal(final Object key); }### Answer: @Test public void testContainsKey() { final CopyOnWriteMap<String, String> map = new CopyOnWriteMap<>(); map.put("a", "b"); assertTrue(map.containsKey("a")); assertFalse(map.containsKey("b")); }
### Question: CopyOnWriteMap implements ConcurrentMap<K, V> { @Override public boolean containsValue(final Object value) { return delegate.containsValue(value); } CopyOnWriteMap(); CopyOnWriteMap(final Map<K, V> existing); @Override synchronized V putIfAbsent(final K key, final V value); @Override synchronized boolean remove(final Object key, final Object value); @Override synchronized boolean replace(final K key, final V oldValue, final V newValue); @Override synchronized V replace(final K key, final V value); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(final Object key); @Override boolean containsValue(final Object value); @Override V get(final Object key); @Override synchronized V put(final K key, final V value); @Override synchronized V remove(final Object key); @Override synchronized void putAll(final Map<? extends K, ? extends V> m); @Override synchronized void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); V removeInternal(final Object key); }### Answer: @Test public void testContainsValue() { final CopyOnWriteMap<String, String> map = new CopyOnWriteMap<>(); map.put("a", "b"); assertFalse(map.containsValue("a")); assertTrue(map.containsValue("b")); }
### Question: CopyOnWriteMap implements ConcurrentMap<K, V> { @Override public Set<Entry<K, V>> entrySet() { return delegate.entrySet(); } CopyOnWriteMap(); CopyOnWriteMap(final Map<K, V> existing); @Override synchronized V putIfAbsent(final K key, final V value); @Override synchronized boolean remove(final Object key, final Object value); @Override synchronized boolean replace(final K key, final V oldValue, final V newValue); @Override synchronized V replace(final K key, final V value); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(final Object key); @Override boolean containsValue(final Object value); @Override V get(final Object key); @Override synchronized V put(final K key, final V value); @Override synchronized V remove(final Object key); @Override synchronized void putAll(final Map<? extends K, ? extends V> m); @Override synchronized void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Entry<K, V>> entrySet(); V removeInternal(final Object key); }### Answer: @Test public void testEntrySet() { final HashMap<String, String> prev = new HashMap<>(); prev.put("a", "b"); final CopyOnWriteMap<String, String> map = new CopyOnWriteMap<>(prev); assertEquals(prev.entrySet(), map.entrySet()); }
### Question: HelloSecurity { @GET @Path("/") @PermitAll public static String hello() { return "Hello world!"; } @GET @Path("/") @PermitAll static String hello(); @GET @Path("/secret") @RolesAllowed("user") static String secret(); @GET @Path("/admin") @RolesAllowed("admin") static String admin(); static void main(final String[] args); }### Answer: @Test public void testHello() { assertEquals("Hello world!", target("/").request().get(String.class)); }
### Question: IdUtils { public static UUID create() { final byte[] bytes = new byte[16]; RANDOM.nextBytes(bytes); final long time = System.currentTimeMillis(); for (int i = 0; i < 6; i++) { bytes[i] = (byte) ((time >> (40 - i * 8)) & 0xFF); } return fromBytes(bytes); } IdUtils(); static UUID create(); static UUID tryParse(final String str); static byte[] toBytes(final UUID id); static UUID fromBytes(final byte[] b); }### Answer: @Test public void testCreate() { final UUID id = IdUtils.create(); assertNotNull(id); }
### Question: IdUtils { public static UUID tryParse(final String str) { if (str == null) { return null; } if (!PATTERN.matcher(str).matches()) { return null; } final String clean = str.replace("-", ""); if (clean.length() != 32) { return null; } final long msb = Long.parseUnsignedLong(clean.substring(0, 16), 16); final long lsb = Long.parseUnsignedLong(clean.substring(16), 16); return new UUID(msb, lsb); } IdUtils(); static UUID create(); static UUID tryParse(final String str); static byte[] toBytes(final UUID id); static UUID fromBytes(final byte[] b); }### Answer: @Test public void testParseNull() { assertNull(IdUtils.tryParse(null)); } @Test public void testParseEmpty() { assertNull(IdUtils.tryParse("")); } @Test public void testParseBadCharacters() { assertNull(IdUtils.tryParse("!@#")); } @Test public void testParseTooShort() { assertNull(IdUtils.tryParse("1234567890")); }
### Question: IdUtils { public static byte[] toBytes(final UUID id) { if (id == null) { return null; } final byte[] buffer = new byte[16]; final ByteBuffer bb = ByteBuffer.wrap(buffer); bb.putLong(id.getMostSignificantBits()); bb.putLong(id.getLeastSignificantBits()); return buffer; } IdUtils(); static UUID create(); static UUID tryParse(final String str); static byte[] toBytes(final UUID id); static UUID fromBytes(final byte[] b); }### Answer: @Test public void testToBytesNull() { assertNull(IdUtils.toBytes(null)); } @Test public void testToBytes() { final UUID id = IdUtils.create(); final byte[] b1 = IdUtils.toBytes(id); final byte[] b2 = IdUtils.toBytes(id); assertNotNull(b1); assertEquals(16, b1.length); assertArrayEquals(b1, b2); }
### Question: IdUtils { public static UUID fromBytes(final byte[] b) { if (b == null \|\| b.length != 16) { return null; } final ByteBuffer bb = ByteBuffer.wrap(b); return new UUID(bb.getLong(), bb.getLong()); } IdUtils(); static UUID create(); static UUID tryParse(final String str); static byte[] toBytes(final UUID id); static UUID fromBytes(final byte[] b); }### Answer: @Test public void testFromBytesNull() { assertNull(IdUtils.fromBytes(null)); } @Test public void testFromBytesTooShort() { assertNull(IdUtils.fromBytes(new byte[] { 1, 2, 3 })); } @Test public void testFromBytesTooLong() { assertNull(IdUtils.fromBytes(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 })); }
### Question: Minitwit { @GET @Path("/public") public Response publicTimeline() { List<Message> messages = dao.getEntityManager() .createQuery("SELECT m FROM Message m ORDER BY m.id DESC", Message.class) .getResultList(); return renderTimeline(messages); } @GET Response timeline(); @GET @Path("/public") Response publicTimeline(); @GET @Path("/{handle}") Response userTimeline(@PathParam("handle") String handle); @GET @Path("/{handle}/follow") @RolesAllowed("user") Response followUser(@PathParam("handle") String handle); @POST @Path("/addmessage") @Consumes(MediaType.APPLICATION_FORM_URLENCODED) @RolesAllowed("user") Response addMessage(@FormParam("text") String text); @GET @Path("/login") View login(); @POST @Path("/login") @Consumes(MediaType.APPLICATION_FORM_URLENCODED) Response login( @FormParam("email") String email, @FormParam("password") String password); @GET @Path("/logout") Response logout(); @GET @Path("/register") View register(); @POST @Path("/register") @Consumes(MediaType.APPLICATION_FORM_URLENCODED) Response register( @FormParam("handle") String handle, @FormParam("email") String email, @FormParam("password") String password); static void main(String[] args); }### Answer: @Test public void testPublicTimeline() { final Response response = target("/public").request().get(); assertNotNull(response); assertEquals(200, response.getStatus()); final View view = (View) response.getEntity(); assertNotNull(view); assertEquals("timeline", view.getTemplateName()); assertNotNull(view.getModel().get("messages")); }
### Question: IOUtils { public static byte[] toByteArray(final InputStream input) throws IOException { final ByteArrayOutputStream output = new ByteArrayOutputStream(); copy(input, output); return output.toByteArray(); } IOUtils(); static byte[] toByteArray(final InputStream input); static InputStream toInputStream(final String str, final Charset charset); static String toString(final InputStream input, final Charset charset); static void copy(final InputStream input, final OutputStream output); }### Answer: @Test public void testToByteArray() throws IOException { final InputStream input = new ByteArrayInputStream("test".getBytes(StandardCharsets.UTF_8)); final byte[] output = IOUtils.toByteArray(input); assertEquals(4, output.length); }
### Question: IOUtils { public static InputStream toInputStream(final String str, final Charset charset) { return new ByteArrayInputStream(str.getBytes(charset)); } IOUtils(); static byte[] toByteArray(final InputStream input); static InputStream toInputStream(final String str, final Charset charset); static String toString(final InputStream input, final Charset charset); static void copy(final InputStream input, final OutputStream output); }### Answer: @Test public void testToInputStream() throws IOException { final InputStream input = IOUtils.toInputStream("test", StandardCharsets.UTF_8); assertEquals("test", IOUtils.toString(input, StandardCharsets.UTF_8)); }
### Question: OptionalClasses { OptionalClasses() { throw new UnsupportedOperationException(); } OptionalClasses(); static final Class<Annotation> SERVER_ENDPOINT; static final Class<?> ENTITY_MANAGER_FACTORY; static final Class<?> ENTITY_MANAGER; }### Answer: @Test public void testOptionalClasses() { assertNotNull(OptionalClasses.ENTITY_MANAGER); assertNull(OptionalClasses.SERVER_ENDPOINT); }
### Question: MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public PersistenceUnitTransactionType getTransactionType() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetTransactionType() { pui.getTransactionType(); }
### Question: MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public DataSource getJtaDataSource() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetJtaDataSource() { pui.getJtaDataSource(); }
### Question: MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public DataSource getNonJtaDataSource() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetNonJtaDataSource() { pui.getNonJtaDataSource(); }
### Question: MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public List<String> getMappingFileNames() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetMappingFileNames() { pui.getMappingFileNames(); }
### Question: MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public List<URL> getJarFileUrls() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetJarFileUrls() { pui.getJarFileUrls(); }
### Question: MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public URL getPersistenceUnitRootUrl() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testGetPersistenceUnitRootUrl() { pui.getPersistenceUnitRootUrl(); }
### Question: MinijaxPersistenceUnitInfo implements javax.persistence.spi.PersistenceUnitInfo { @Override public boolean excludeUnlistedClasses() { throw new UnsupportedOperationException(); } MinijaxPersistenceUnitInfo(final String name, final String providerClassName); @Override String getPersistenceUnitName(); @Override String getPersistenceProviderClassName(); @Override List<String> getManagedClassNames(); @Override Properties getProperties(); @Override PersistenceUnitTransactionType getTransactionType(); @Override DataSource getJtaDataSource(); @Override DataSource getNonJtaDataSource(); @Override List<String> getMappingFileNames(); @Override List<URL> getJarFileUrls(); @Override URL getPersistenceUnitRootUrl(); @Override boolean excludeUnlistedClasses(); @Override SharedCacheMode getSharedCacheMode(); @Override ValidationMode getValidationMode(); @Override String getPersistenceXMLSchemaVersion(); @Override ClassLoader getClassLoader(); @Override void addTransformer(final ClassTransformer transformer); @Override ClassLoader getNewTempClassLoader(); }### Answer: @Test(expected = UnsupportedOperationException.class) public void testExcludeUnlistedClasses() { pui.excludeUnlistedClasses(); }
### Question: Minitwit { @GET @Path("/{handle}/follow") @RolesAllowed("user") public Response followUser(@PathParam("handle") String handle) { security.getUserPrincipal().following.add(dao.readByHandle(User.class, handle)); dao.update(security.getUserPrincipal()); return Response.seeOther(URI.create("/")).build(); } @GET Response timeline(); @GET @Path("/public") Response publicTimeline(); @GET @Path("/{handle}") Response userTimeline(@PathParam("handle") String handle); @GET @Path("/{handle}/follow") @RolesAllowed("user") Response followUser(@PathParam("handle") String handle); @POST @Path("/addmessage") @Consumes(MediaType.APPLICATION_FORM_URLENCODED) @RolesAllowed("user") Response addMessage(@FormParam("text") String text); @GET @Path("/login") View login(); @POST @Path("/login") @Consumes(MediaType.APPLICATION_FORM_URLENCODED) Response login( @FormParam("email") String email, @FormParam("password") String password); @GET @Path("/logout") Response logout(); @GET @Path("/register") View register(); @POST @Path("/register") @Consumes(MediaType.APPLICATION_FORM_URLENCODED) Response register( @FormParam("handle") String handle, @FormParam("email") String email, @FormParam("password") String password); static void main(String[] args); }### Answer: @Test public void testFollowUser() throws Exception { assertFalse(alice.following.contains(bob)); final Response response = target("/bob/follow").request().cookie(aliceCookie).get(); assertNotNull(response); assertEquals(303, response.getStatus()); try (final MinijaxRequestContext ctx = createRequestContext()) { final Dao dao = ctx.getResource(Dao.class); assertTrue(dao.read(User.class, alice.getId()).following.contains(bob)); } }
### Question: CharEscapeUtil { public static String escape(String s) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); if (c == '=' \|\| c == '\\' \|\| c == '+' \|\| c == '-' \|\| c == '!' \|\| c == '(' \|\| c == ')' \|\| c == ':' \|\| c == '^' \|\| c == '[' \|\| c == ']' \|\| c == '\"' \|\| c == '{' \|\| c == '}' \|\| c == '~' \|\| c == '*' \|\| c == '?' \|\| c == '\|' \|\| c == '&' \|\| c == '/') { sb.append('\\'); } sb.append(c); } return sb.toString(); } CharEscapeUtil( Writer w,int features); CharEscapeUtil( ); CharEscapeUtil( Writer w); Object getOutputTarget(); int getOutputBuffered(); boolean canWriteFormattedNumbers(); void writeString(String text,boolean flush); String toString(); void _writeString(String text); void _writeString2(final int len); static String escape(String s); }### Answer: @Test public void escape(){ StringWriter writer = new StringWriter(); CharEscapeUtil charEscapeUtil = new CustomCharEscapeUtil(writer); charEscapeUtil.writeString("/+\"\\", true); System.out.println(writer.toString()); }
### Question: ManageHousekeepingService implements ChannelEventListener { @Override public void onChannelClose(String remoteAddr, Channel channel) { this.namesrvController.getRouteInfoManager().onChannelDestroy(remoteAddr, channel); } ManageHousekeepingService(NameSrvController namesrvController); @Override void onChannelConnect(String remoteAddr, Channel channel); @Override void onChannelClose(String remoteAddr, Channel channel); @Override void onChannelException(String remoteAddr, Channel channel); @Override void onChannelIdle(String remoteAddr, Channel channel); }### Answer: @Test public void testOnChannelClose() { brokerHousekeepingService.onChannelClose("127.0.0.1:9876", null); }
### Question: ManageHousekeepingService implements ChannelEventListener { @Override public void onChannelException(String remoteAddr, Channel channel) { this.namesrvController.getRouteInfoManager().onChannelDestroy(remoteAddr, channel); } ManageHousekeepingService(NameSrvController namesrvController); @Override void onChannelConnect(String remoteAddr, Channel channel); @Override void onChannelClose(String remoteAddr, Channel channel); @Override void onChannelException(String remoteAddr, Channel channel); @Override void onChannelIdle(String remoteAddr, Channel channel); }### Answer: @Test public void testOnChannelException() { brokerHousekeepingService.onChannelException("127.0.0.1:9876", null); }
### Question: ManageHousekeepingService implements ChannelEventListener { @Override public void onChannelIdle(String remoteAddr, Channel channel) { this.namesrvController.getRouteInfoManager().onChannelDestroy(remoteAddr, channel); } ManageHousekeepingService(NameSrvController namesrvController); @Override void onChannelConnect(String remoteAddr, Channel channel); @Override void onChannelClose(String remoteAddr, Channel channel); @Override void onChannelException(String remoteAddr, Channel channel); @Override void onChannelIdle(String remoteAddr, Channel channel); }### Answer: @Test public void testOnChannelIdle() { brokerHousekeepingService.onChannelException("127.0.0.1:9876", null); }
### Question: RouteInfoManager { public byte[] getGtsManagerInfo() { LiveManageInfo liveManageInfo = new LiveManageInfo(); List<GtsManageLiveAddr> brokerLiveAddrs=this.liveTable.values().stream(). filter(item->Objects.nonNull(item)). map(item-> new GtsManageLiveAddr(item.getGtsManageId(), item.getLastUpdateTimestamp(),item.getGtsManageName(), item.getGtsManageAddr())). collect(Collectors.toList()); liveManageInfo.setGtsManageLiveAddrs(brokerLiveAddrs); return liveManageInfo.encode(); } RouteInfoManager(); byte[] getGtsManagerInfo(); RegisterBrokerResult registerBroker( String brokerAddr, String brokerName, long brokerId, TopicConfigSerializeWrapper topicConfigWrapper, Channel channel); void unregisterBroker( String brokerAddr, String brokerName, long brokerId); void scanNotActiveBroker(); void onChannelDestroy(String remoteAddr, Channel channel); }### Answer: @Test public void testGetAllClusterInfo() { byte[] clusterInfo = routeInfoManager.getGtsManagerInfo(); assertThat(clusterInfo).isNotNull(); }
### Question: DefaultRequestProcessor implements NettyRequestProcessor { @Override public RemotingCommand processRequest(ChannelHandlerContext ctx,RemotingCommand request) throws RemotingCommandException { if (log.isDebugEnabled()) { log.debug("receive request, {} {} {}", request.getCode(), RemotingHelper.parseChannelRemoteAddr(ctx.channel()), request); } switch (request.getCode()) { case RequestCode.REGISTER_MANAGE: return this.registerBrokerWithFilterServer(ctx, request); case RequestCode.UNREGISTER_MANAGE: return this.unregisterBroker(ctx, request); case RequestCode.GET_MANAGE_CLUSTER_INFO: return this.getBrokerClusterInfo(ctx, request); default: break; } return null; } DefaultRequestProcessor(NameSrvController namesrvController); @Override RemotingCommand processRequest(ChannelHandlerContext ctx,RemotingCommand request); @Override boolean rejectRequest(); RemotingCommand registerBrokerWithFilterServer(ChannelHandlerContext ctx, RemotingCommand request); RemotingCommand unregisterBroker(ChannelHandlerContext ctx,RemotingCommand request); }### Answer: @Test public void testProcessRequest_UnregisterBroker() throws RemotingCommandException, NoSuchFieldException, IllegalAccessException { ChannelHandlerContext ctx = mock(ChannelHandlerContext.class); when(ctx.channel()).thenReturn(null); RemotingCommand regRequest = genSampleRegisterCmd(true); defaultRequestProcessor.processRequest(ctx, regRequest); RemotingCommand unregRequest = genSampleRegisterCmd(false); RemotingCommand unregResponse = defaultRequestProcessor.processRequest(ctx, unregRequest); assertThat(unregResponse.getCode()).isEqualTo(ResponseCode.SUCCESS); assertThat(unregResponse.getRemark()).isNull(); RouteInfoManager routes = namesrvController.getRouteInfoManager(); Field brokerAddrTable = RouteInfoManager.class.getDeclaredField("brokerAddrTable"); brokerAddrTable.setAccessible(true); assertThat((Map) brokerAddrTable.get(routes)).isNotEmpty(); }
### Question: FrequentlyRelatedContentRequestParameterValidator implements SearchRequestParameterValidator { @Override public ValidationMessage validateParameters(Map<String, String> requestParameters) { String id = requestParameters.get(idParameter); if(id == null \|\| id.length()==0) return INVALID_ID_MESSAGE; else return VALID_ID_MESSAGE; } FrequentlyRelatedContentRequestParameterValidator(Configuration configuration); @Override ValidationMessage validateParameters(Map<String, String> requestParameters); final ValidationMessage VALID_ID_MESSAGE; final ValidationMessage INVALID_ID_MESSAGE; }### Answer: @Test public void testMissingIdParameterReturnsInvalidMessage() { ValidationMessage message = validator.validateParameters(new HashMap<String, String>()); assertSame(message,validator.INVALID_ID_MESSAGE); } @Test public void testIdParameterReturnsValidMessage() { ValidationMessage message = validator.validateParameters(new HashMap<String, String>(){{ put(configuration.getKeyForFrequencyResultId(),"11111");}}); assertSame(message,validator.VALID_ID_MESSAGE); }
### Question: RelatedItemSearchFactoryWithSearchLookupKeyFactory implements RelatedItemSearchFactory { @Override public RelatedItemSearch createSearchObject() { return new RelatedItemSearch(configuration); } RelatedItemSearchFactoryWithSearchLookupKeyFactory(Configuration config, RelatedItemSearchLookupKeyGenerator lookupKeyGenerator); @Override RelatedItemSearch createSearchObject(); @Override void populateSearchObject(RelatedItemSearch objectToPopulate, RelatedItemSearchType type, Map<String, String> properties); @Override RelatedItemSearch newInstance(); }### Answer: @Test public void testCreateSearchObject() throws Exception { assertNotNull(factory.createSearchObject()); }
### Question: RelatedItemSearchFactoryWithSearchLookupKeyFactory implements RelatedItemSearchFactory { @Override public RelatedItemSearch newInstance() { return createSearchObject(); } RelatedItemSearchFactoryWithSearchLookupKeyFactory(Configuration config, RelatedItemSearchLookupKeyGenerator lookupKeyGenerator); @Override RelatedItemSearch createSearchObject(); @Override void populateSearchObject(RelatedItemSearch objectToPopulate, RelatedItemSearchType type, Map<String, String> properties); @Override RelatedItemSearch newInstance(); }### Answer: @Test public void testNewInstance() throws Exception { assertNotNull(factory.newInstance()); }
### Question: RelatedItemIndexingMessageFactory implements EventFactory<RelatedItemIndexingMessage> { @Override public RelatedItemIndexingMessage newInstance() { return new RelatedItemIndexingMessage(configuration); } RelatedItemIndexingMessageFactory(Configuration configuration); @Override RelatedItemIndexingMessage newInstance(); }### Answer: @Test public void testRelatedItemIndexingMessageWith4RelatedItems() throws Exception { System.setProperty(PROPNAME_MAX_NO_OF_RELATED_ITEMS_PER_INDEX_REQUEST,"4"); Configuration config = new SystemPropertiesConfiguration(); RelatedItemIndexingMessageFactory factory = new RelatedItemIndexingMessageFactory(config); RelatedItemIndexingMessage message = factory.newInstance(); assertEquals(4, message.getMaxNumberOfRelatedItemsAllowed()); } @Test public void testRelatedItemIndexingMessage() { System.setProperty(PROPNAME_MAX_NO_OF_RELATED_ITEMS_PER_INDEX_REQUEST,"2"); Configuration config = new SystemPropertiesConfiguration(); RelatedItemIndexingMessageFactory factory = new RelatedItemIndexingMessageFactory(config); RelatedItemIndexingMessage message = factory.newInstance(); assertEquals(2, message.getMaxNumberOfRelatedItemsAllowed()); } @Test public void testRelatedItemIndexingMessageRestrictsNumberOfProperties() { System.setProperty(PROPNAME_MAX_NO_OF_RELATED_ITEMS_PER_INDEX_REQUEST,"2"); System.setProperty(PROPNAME_MAX_NO_OF_RELATED_ITEM_PROPERTES,"3"); Configuration config = new SystemPropertiesConfiguration(); RelatedItemIndexingMessageFactory factory = new RelatedItemIndexingMessageFactory(config); RelatedItemIndexingMessage message = factory.newInstance(); assertEquals(2, message.getMaxNumberOfRelatedItemsAllowed()); assertEquals(3, message.getIndexingMessageProperties().getMaxNumberOfAvailableProperties()); }
### Question: RelatedItemReferenceMessageFactory implements EventFactory<RelatedItemReference> { @Override public RelatedItemReference newInstance() { return new RelatedItemReference(); } RelatedItemReferenceMessageFactory(); @Override RelatedItemReference newInstance(); }### Answer: @Test public void testCanCreateReferenceObject() { EventFactory<RelatedItemReference> factory = new RelatedItemReferenceMessageFactory(); assertNotNull(factory.newInstance()); assertTrue(factory.newInstance() instanceof RelatedItemReference); }
### Question: AHCHttpSniffAvailableNodes implements SniffAvailableNodes { @Override public Set<String> getAvailableNodes(String[] hosts) { Set<String> newHosts = new TreeSet<>(); for(String host : hosts) { HttpResult result = AHCRequestExecutor.executeSearch(client, HttpMethod.GET, host, NODE_ENDPOINT, null); if(result.getStatus()== HttpSearchExecutionStatus.OK) { newHosts.addAll(HostParsingUtil.parseAvailablePublishedHttpServerAddresses(result.getResult())); } } return newHosts; } AHCHttpSniffAvailableNodes(Configuration configuration); @Override Set<String> getAvailableNodes(String[] hosts); @Override void shutdown(); final String NODE_ENDPOINT; }### Answer: @Test public void testOneHostIsContacted() { Set<String> hosts = nodeSniffer.getAvailableNodes(new String[]{"http: assertEquals("Should be one host",1,hosts.size()); assertEquals("parsed host should be: http: wireMockRule1.verify(1,getRequestedFor(urlMatching(ConfigurationConstants.DEFAULT_ELASTIC_SEARCH_HTTP_NODE_SNIFFING_ENDPOINT))); wireMockRule2.verify(0,getRequestedFor(urlMatching(ConfigurationConstants.DEFAULT_ELASTIC_SEARCH_HTTP_NODE_SNIFFING_ENDPOINT))); } @Test public void testBothHostIsContacted() { Set<String> hosts = nodeSniffer.getAvailableNodes(new String[]{"http: assertEquals("Should be one host",3,hosts.size()); assertEquals("parsed host should be: http: assertEquals("parsed host should be: http: assertEquals("parsed host should be: http: wireMockRule1.verify(1,getRequestedFor(urlMatching(ConfigurationConstants.DEFAULT_ELASTIC_SEARCH_HTTP_NODE_SNIFFING_ENDPOINT))); wireMockRule2.verify(1,getRequestedFor(urlMatching(ConfigurationConstants.DEFAULT_ELASTIC_SEARCH_HTTP_NODE_SNIFFING_ENDPOINT))); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.