method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
EhcacheWebServiceEndpoint { @WebMethod public void loadAll(String cacheName, Collection<String> keys) throws CacheException { net.sf.ehcache.Cache cache = lookupCache(cacheName); cache.loadAll(keys, null); } @WebMethod String ping(); @WebMethod Cache getCache(String cacheName); @WebMethod void addCache(String cacheName); @WebMethod void removeCache(String cacheName); @WebMethod String[] cacheNames(); @WebMethod Status getStatus(String cacheName); @WebMethod void put(String cacheName, Element element); @WebMethod Element get(String cacheName, String key); @WebMethod List getKeys(String cacheName); @WebMethod boolean remove(String cacheName, String key); @WebMethod List getKeysWithExpiryCheck(String cacheName); @WebMethod List getKeysNoDuplicateCheck(String cacheName); @WebMethod Element getQuiet(String cacheName, Object key); @WebMethod void putQuiet(String cacheName, Element element); @WebMethod boolean removeQuiet(String cacheName, String key); @WebMethod void removeAll(String cacheName); @WebMethod int getSize(String cacheName); @WebMethod Statistics getStatistics(String cacheName); @WebMethod StatisticsAccuracy getStatisticsAccuracy(String cacheName); @WebMethod void clearStatistics(String cacheName); @WebMethod void load(String cacheName, String key); @WebMethod void loadAll(String cacheName, Collection<String> keys); @WebMethod HashMap getAllWithLoader(String cacheName, Collection keys); @WebMethod Element getWithLoader(String cacheName, String key); }### Answer:
@Test public void testLoadAll() throws NoSuchCacheException_Exception, CacheException_Exception, IllegalStateException_Exception { List keys = new ArrayList(); for (int i = 0; i < 5; i++) { keys.add("" + i); } cacheService.loadAll("sampleCache1", keys); } |
### Question:
EhcacheWebServiceEndpoint { @WebMethod public Element getWithLoader(String cacheName, String key) { net.sf.ehcache.Cache cache = lookupCache(cacheName); net.sf.ehcache.Element element = cache.getWithLoader(key, null, null); if (element != null) { return new Element(element); } else { return null; } } @WebMethod String ping(); @WebMethod Cache getCache(String cacheName); @WebMethod void addCache(String cacheName); @WebMethod void removeCache(String cacheName); @WebMethod String[] cacheNames(); @WebMethod Status getStatus(String cacheName); @WebMethod void put(String cacheName, Element element); @WebMethod Element get(String cacheName, String key); @WebMethod List getKeys(String cacheName); @WebMethod boolean remove(String cacheName, String key); @WebMethod List getKeysWithExpiryCheck(String cacheName); @WebMethod List getKeysNoDuplicateCheck(String cacheName); @WebMethod Element getQuiet(String cacheName, Object key); @WebMethod void putQuiet(String cacheName, Element element); @WebMethod boolean removeQuiet(String cacheName, String key); @WebMethod void removeAll(String cacheName); @WebMethod int getSize(String cacheName); @WebMethod Statistics getStatistics(String cacheName); @WebMethod StatisticsAccuracy getStatisticsAccuracy(String cacheName); @WebMethod void clearStatistics(String cacheName); @WebMethod void load(String cacheName, String key); @WebMethod void loadAll(String cacheName, Collection<String> keys); @WebMethod HashMap getAllWithLoader(String cacheName, Collection keys); @WebMethod Element getWithLoader(String cacheName, String key); }### Answer:
@Test public void testGetWithLoad() throws NoSuchCacheException_Exception, CacheException_Exception, IllegalStateException_Exception { cacheService.getWithLoader("sampleCache1", "2"); } |
### Question:
EhcacheWebServiceEndpoint { @WebMethod public HashMap getAllWithLoader(String cacheName, Collection keys) throws CacheException { net.sf.ehcache.Cache cache = lookupCache(cacheName); return (HashMap) cache.getAllWithLoader(keys, null); } @WebMethod String ping(); @WebMethod Cache getCache(String cacheName); @WebMethod void addCache(String cacheName); @WebMethod void removeCache(String cacheName); @WebMethod String[] cacheNames(); @WebMethod Status getStatus(String cacheName); @WebMethod void put(String cacheName, Element element); @WebMethod Element get(String cacheName, String key); @WebMethod List getKeys(String cacheName); @WebMethod boolean remove(String cacheName, String key); @WebMethod List getKeysWithExpiryCheck(String cacheName); @WebMethod List getKeysNoDuplicateCheck(String cacheName); @WebMethod Element getQuiet(String cacheName, Object key); @WebMethod void putQuiet(String cacheName, Element element); @WebMethod boolean removeQuiet(String cacheName, String key); @WebMethod void removeAll(String cacheName); @WebMethod int getSize(String cacheName); @WebMethod Statistics getStatistics(String cacheName); @WebMethod StatisticsAccuracy getStatisticsAccuracy(String cacheName); @WebMethod void clearStatistics(String cacheName); @WebMethod void load(String cacheName, String key); @WebMethod void loadAll(String cacheName, Collection<String> keys); @WebMethod HashMap getAllWithLoader(String cacheName, Collection keys); @WebMethod Element getWithLoader(String cacheName, String key); }### Answer:
@Test public void testGetAllWithLoader() throws NoSuchCacheException_Exception, CacheException_Exception, IllegalStateException_Exception { List keys = new ArrayList(); for (int i = 0; i < 5; i++) { keys.add("" + i); } cacheService.getAllWithLoader("sampleCache1", keys); } |
### Question:
JCache implements net.sf.jsr107cache.Cache { public String toString() { return cache.toString(); } JCache(Ehcache cache); JCache(Ehcache cache, net.sf.jsr107cache.CacheLoader cacheLoader); JCache(Ehcache cache, JCacheLoader cacheLoader); void setCacheLoader(JCacheLoader cacheLoader); void addListener(CacheListener cacheListener); void evict(); Map getAll(Collection keys); Map getAll(Collection keys, Object loaderArgument); CacheLoader getCacheLoader(); CacheEntry getCacheEntry(Object key); CacheStatistics getCacheStatistics(); void load(final Object key); void loadAll(final Collection keys); void loadAll(final Collection keys, final Object loaderArgument); Object peek(Object key); void removeListener(CacheListener cacheListener); int size(); boolean isEmpty(); boolean containsKey(Object key); boolean containsValue(Object value); Object get(Object key); Object get(Object key, Object loaderArgument); Object get(Object key, JCacheLoader loader); Object get(Object key, JCacheLoader loader, Object loaderArgument); Object put(Object key, Object value); Object put(Object key, Object value, int timeToLiveSeconds); Object remove(Object key); void putAll(Map sourceMap); void clear(); Set keySet(); Collection values(); Set entrySet(); void setStatisticsAccuracy(int statisticsAccuracy); Ehcache getBackingCache(); String toString(); }### Answer:
@Test public void testToString() throws CacheException { Cache cache = getTest2Cache(); cache.clear(); LOG.info(cache.toString()); assertTrue(cache.toString().indexOf("test2jcache") > -1); assertTrue(380 < cache.toString().length()); } |
### Question:
JCache implements net.sf.jsr107cache.Cache { public void load(final Object key) throws CacheException { cache.load(key); } JCache(Ehcache cache); JCache(Ehcache cache, net.sf.jsr107cache.CacheLoader cacheLoader); JCache(Ehcache cache, JCacheLoader cacheLoader); void setCacheLoader(JCacheLoader cacheLoader); void addListener(CacheListener cacheListener); void evict(); Map getAll(Collection keys); Map getAll(Collection keys, Object loaderArgument); CacheLoader getCacheLoader(); CacheEntry getCacheEntry(Object key); CacheStatistics getCacheStatistics(); void load(final Object key); void loadAll(final Collection keys); void loadAll(final Collection keys, final Object loaderArgument); Object peek(Object key); void removeListener(CacheListener cacheListener); int size(); boolean isEmpty(); boolean containsKey(Object key); boolean containsValue(Object value); Object get(Object key); Object get(Object key, Object loaderArgument); Object get(Object key, JCacheLoader loader); Object get(Object key, JCacheLoader loader, Object loaderArgument); Object put(Object key, Object value); Object put(Object key, Object value, int timeToLiveSeconds); Object remove(Object key); void putAll(Map sourceMap); void clear(); Set keySet(); Collection values(); Set entrySet(); void setStatisticsAccuracy(int statisticsAccuracy); Ehcache getBackingCache(); String toString(); }### Answer:
@Test public void testLoad() throws InterruptedException, ExecutionException, CacheException { CountingCacheLoader countingCacheLoader = new CountingCacheLoader(); JCache jcache = new JCache(manager.getCache("sampleCache1"), countingCacheLoader); jcache.load("key1"); Thread.sleep(500); assertEquals(1, jcache.size()); assertEquals(1, countingCacheLoader.getLoadCounter()); } |
### Question:
JCacheEntry implements CacheEntry { public long getCost() { return 0; } JCacheEntry(Element element); Object getKey(); Object getValue(); Object setValue(Object value); long getCost(); long getCreationTime(); long getExpirationTime(); int getHits(); long getLastAccessTime(); long getLastUpdateTime(); long getVersion(); boolean isValid(); }### Answer:
@Test public void testCost() throws Exception { Cache cache = getTestCache(); CacheEntry entry = new JCacheEntry(new Element("key1", "value1")); assertEquals(0L, entry.getCost()); } |
### Question:
MyLinkedList implements MyList { @Override public void add(int val) { throw new UnsupportedOperationException(); } @Override int get(int pos); @Override void add(int val); @Override int removeFirst(); @Override int size(); @Override boolean isEmpty(); }### Answer:
@Test public void add() throws Exception { } |
### Question:
ReflectionHelper { static <T> T instantiate(Class<T> type, Object... args) { try { if (args.length == 0) { return type.newInstance(); } else { return type.getConstructor(toClasses(args)).newInstance(args); } } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) { e.printStackTrace(); } return null; } private ReflectionHelper(); }### Answer:
@SuppressWarnings("ConstantConditions") @Test public void instantiate() { TestClass testClass = ReflectionHelper.instantiate(TestClass.class); Assert.assertEquals(0, testClass.getA()); Assert.assertEquals(1, ReflectionHelper.instantiate(TestClass.class, 1).getA()); Assert.assertEquals("A", ReflectionHelper.instantiate(TestClass.class, 1, "A").getS()); }
@SuppressWarnings("ConstantConditions") @Test public void instantiate() { Assert.assertEquals(0, ReflectionHelper.instantiate(TestClass.class).getA()); Assert.assertEquals(1, ReflectionHelper.instantiate(TestClass.class, 1).getA()); Assert.assertEquals("A", ReflectionHelper.instantiate(TestClass.class, 1, "A").getS()); } |
### Question:
MyLinkedList implements MyList { @Override public int removeFirst() throws ListException { throw new UnsupportedOperationException(); } @Override int get(int pos); @Override void add(int val); @Override int removeFirst(); @Override int size(); @Override boolean isEmpty(); }### Answer:
@Test public void removeFirst() throws Exception { }
@Test(expected = ListException.class) public void removeFirst_Empty() throws Exception { MyList list = new MyLinkedList(); list.removeFirst(); } |
### Question:
MyLinkedList implements MyList { @Override public int size() { throw new UnsupportedOperationException(); } @Override int get(int pos); @Override void add(int val); @Override int removeFirst(); @Override int size(); @Override boolean isEmpty(); }### Answer:
@Test public void size() throws Exception { } |
### Question:
MyLinkedList implements MyList { @Override public boolean isEmpty() { throw new UnsupportedOperationException(); } @Override int get(int pos); @Override void add(int val); @Override int removeFirst(); @Override int size(); @Override boolean isEmpty(); }### Answer:
@Test public void isEmpty() throws Exception { MyList list = new MyLinkedList(); assertTrue(list.isEmpty()); list.add(1); assertFalse(list.isEmpty()); } |
### Question:
Lottery { void run() { List<String> emails = emailsSource.get(); System.out.println("Emails count: " + emails.size()); List<String> winners = machine.setSeed(seedString).draw(emails); System.out.println("Winners:"); winners.forEach(System.out::println); } Lottery(Supplier<List<String>> emailsSource,
LotteryMachine machine,
String seedString); }### Answer:
@Test public void mockedLottery() { EmailsReader emailsReader = Mockito.mock(EmailsReader.class); LotteryMachine lotteryMachine = Mockito.mock(LotteryMachine.class); String seedString = "May the Test be with you"; when(emailsReader.get()).thenReturn(Arrays.asList("0", "1", "2", "3", "4")); when(lotteryMachine.setSeed(seedString)).thenReturn(lotteryMachine); Lottery lottery = new Lottery(emailsReader, lotteryMachine, seedString); lottery.run(); Mockito.verify(emailsReader, Mockito.times(1)).get(); Mockito.verify(lotteryMachine, Mockito.times(1)).setSeed(seedString); Mockito.verify(lotteryMachine, Mockito.never()).dispose(); }
@Test public void mockedWithSpy() { EmailsReader emailsReader = Mockito.mock(EmailsReader.class); LotteryMachine lotteryMachine = new LotteryMachine(5); LotteryMachine spyMachine = Mockito.spy(lotteryMachine); String seedString = "Test"; long longSeed = 1L; when(spyMachine.getSeed()).thenReturn(longSeed); Lottery lottery = new Lottery(emailsReader, spyMachine, seedString); lottery.run(); Assert.assertEquals(LotteryMachine.DEFAULT_SEED, lotteryMachine.getSeed()); Assert.assertEquals(longSeed, spyMachine.getSeed()); } |
### Question:
LotteryMachine { List<String> draw(List<String> emails) { System.out.println("Draw for the seed: " + getSeed()); Random rnd = new Random(getSeed()); Set<String> winners = new HashSet<>(); while (winners.size() < Math.min(winnersCount, emails.size())) { int index = rnd.nextInt(emails.size()); System.out.println("Ball: " + index); winners.add(emails.get(index)); } return new ArrayList<>(winners); } LotteryMachine(int winnersCount); }### Answer:
@Test(timeout = 10) public void oneEmail() throws InterruptedException { LotteryMachine machine = new LotteryMachine(2); List<String> result = machine.draw(Collections.singletonList("test")); Assert.assertEquals(1, result.size()); }
@Ignore("todo: 13131") @Test(timeout = 100) public void fiveEmails() { List<String> result = lotteryMachine .draw(Arrays.asList("0", "1", "2", "3", "4")); assertEquals(5, result.size()); Assert.assertTrue(result.contains("0")); Assert.assertTrue(result.contains("1")); Assert.assertTrue(result.contains("2")); Assert.assertTrue(result.contains("3")); Assert.assertTrue(result.contains("4")); } |
### Question:
BaseRequest extends AbstractRequest<T> { @Nullable public Object getJsonObject() { return jsonObject; } protected BaseRequest(Builder builder); @NonNull String getJsonContentType(); @Override @NonNull String getBodyContentType(); @Nullable byte[] getJsonBody(); @Override @NonNull String getUrl(); @Nullable Object getJsonObject(); @Override @Nullable Map<String, String> getParams(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void builderGenerationNoJsonInGet() throws Exception { BaseRequest.Builder<DummyResponse> builder = new BaseRequest.Builder<>(Request.Method.GET, url, DummyResponse.class); builder.json(dummyRequestObject); BaseRequest<DummyResponse> baseRequest = builder.build(); baseRequest.getJsonObject(); } |
### Question:
MultipartRequest extends BaseRequest<T> { @Override @NonNull public String getBodyContentType() { return "multipart/form-data;boundary=" + boundary; } private MultipartRequest(Builder<T> builder); @Override @NonNull String getBodyContentType(); @Nullable HashMap<String, List<RequestData>> getMultiPartData(); @NonNull String getJsonKey(); }### Answer:
@Test public void requestPostConstruct_contentType() throws Exception { MultipartRequest.Builder<DummyResponse> builder = new MultipartRequest.Builder<>(Request.Method.POST, url, DummyResponse.class); builder.json(dummyRequestObject); builder.headers(headers); builder.multiPartDataList(dummyDataMap); MultipartRequest<DummyResponse> baseRequest = builder.build(); assertTrue(baseRequest.getBodyContentType().startsWith("multipart/form-data;boundary=")); assertNotEquals("multipart/form-data;boundary=", baseRequest.getBodyContentType()); assertNotNull(baseRequest.getBody()); }
@Test public void requestPostParamConstruct_contentType() throws Exception { MultipartRequest.Builder<DummyResponse> builder = new MultipartRequest.Builder<>(Request.Method.POST, url, DummyResponse.class); builder.parameters(parameters); builder.headers(headers); builder.multiPartDataList(dummyDataMap); MultipartRequest<DummyResponse> baseRequest = builder.build(); assertTrue(baseRequest.getBodyContentType().startsWith("multipart/form-data;boundary=")); assertNotEquals("multipart/form-data;boundary=", baseRequest.getBodyContentType()); assertNotNull(baseRequest.getBody()); } |
### Question:
SpitfireManager { @NonNull public static ObjectMapper getObjectMapper() { if (objectMapper == null) { objectMapper = new ObjectMapper(); objectMapper.configure(SerializationFeature.INDENT_OUTPUT, false); objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); } return objectMapper; } static void setRequestTimeout(int timeout); static void setDefaultRetryPolicy(@NonNull DefaultRetryPolicy newRetryPolicy); @NonNull static RetryPolicy getDefaultRetryPolicy(); @NonNull static ObjectMapper getObjectMapper(); static void setObjectMapper(@NonNull ObjectMapper objectMapper); }### Answer:
@Test public void objectMapperGetIsNotNull() throws Exception { assertNotNull(SpitfireManager.getObjectMapper()); } |
### Question:
SpitfireManager { public static void setObjectMapper(@NonNull ObjectMapper objectMapper) { if (objectMapper == null) { throw new IllegalArgumentException("Object mapper should not be null"); } SpitfireManager.objectMapper = objectMapper; } static void setRequestTimeout(int timeout); static void setDefaultRetryPolicy(@NonNull DefaultRetryPolicy newRetryPolicy); @NonNull static RetryPolicy getDefaultRetryPolicy(); @NonNull static ObjectMapper getObjectMapper(); static void setObjectMapper(@NonNull ObjectMapper objectMapper); }### Answer:
@Test(expected = IllegalArgumentException.class) public void objectMapperNotNullTest() throws Exception { SpitfireManager.setObjectMapper(null); } |
### Question:
BaseRequest extends AbstractRequest<T> { @Override @NonNull public String getUrl() { int method = getMethod(); String topUrl = super.getUrl(); if (method == Method.GET) { return parseGetUrl(method, topUrl, getParams(), getParamsEncoding()); } return topUrl; } protected BaseRequest(Builder builder); @NonNull String getJsonContentType(); @Override @NonNull String getBodyContentType(); @Nullable byte[] getJsonBody(); @Override @NonNull String getUrl(); @Nullable Object getJsonObject(); @Override @Nullable Map<String, String> getParams(); }### Answer:
@Test public void builderPostGenerationWierdValue() throws Exception { BaseRequest.Builder<DummyResponse> builder = new BaseRequest.Builder<>(Request.Method.POST, url, DummyResponse.class); builder.headers(headersWithContentType); BaseRequest<DummyResponse> baseRequest = builder.build(); assertEquals("The url should be the same", url, baseRequest.getUrl()); assertEquals("The method should be the same", Request.Method.POST, baseRequest.getMethod()); Map returnedMap = baseRequest.getHeaders(); for (String key : headersWithContentType.keySet()) { assertTrue("The key should be contained", returnedMap.containsKey(key)); assertEquals("The same value should be contained", headersWithContentType.get(key), returnedMap.get(key)); } }
@Test public void builderPatchGenerationWierdValue() throws Exception { BaseRequest.Builder<DummyResponse> builder = new BaseRequest.Builder<>(Request.Method.PATCH, url, DummyResponse.class); builder.headers(headersWithContentType); BaseRequest<DummyResponse> baseRequest = builder.build(); assertEquals("The url should be the same", url, baseRequest.getUrl()); assertEquals("The method should be the same", Request.Method.PATCH, baseRequest.getMethod()); Map returnedMap = baseRequest.getHeaders(); for (String key : headersWithContentType.keySet()) { assertTrue("The key should be contained", returnedMap.containsKey(key)); assertEquals("The same value should be contained", headersWithContentType.get(key), returnedMap.get(key)); } } |
### Question:
JMSExceptionSupport { public static MessageFormatException createMessageFormatException(Throwable cause) { String message = cause.getMessage(); if (message == null || message.length() == 0) { message = cause.toString(); } MessageFormatException exception = new MessageFormatException(message); if (cause instanceof Exception) { exception.setLinkedException((Exception) cause); } exception.initCause(cause); return exception; } static JMSException create(String message, Throwable cause); static JMSException create(Throwable cause); static MessageEOFException createMessageEOFException(Throwable cause); static MessageFormatException createMessageFormatException(Throwable cause); static JMSRuntimeException createRuntimeException(Exception exception); }### Answer:
@Test public void testCreateMessageFormatExceptionFillsMessageFromCauseMessageParamToString() { JMSException result = JMSExceptionSupport.createMessageFormatException(NO_MESSAGE_CAUSE); assertEquals(NO_MESSAGE_CAUSE.toString(), result.getMessage()); }
@Test public void testCreateMessageFormatExceptionFillsMessageFromCauseMessageParamToStringWhenMessageIsEmpty() { JMSException result = JMSExceptionSupport.createMessageFormatException(EMPTY_MESSAGE_CAUSE); assertEquals(EMPTY_MESSAGE_CAUSE.toString(), result.getMessage()); }
@Test public void testCreateMessageFormatExceptionAssignsLinkedException() { JMSException result = JMSExceptionSupport.createMessageFormatException(new IOException(CAUSE_MESSAGE)); assertNotNull(result.getLinkedException()); }
@Test public void testCreateMessageFormatExceptionDoesNotFillLinkedExceptionWhenGivenNonExceptionThrowable() { JMSException result = JMSExceptionSupport.createMessageFormatException(new AssertionError(CAUSE_MESSAGE)); assertNull(result.getLinkedException()); } |
### Question:
JMSExceptionSupport { public static MessageEOFException createMessageEOFException(Throwable cause) { String message = cause.getMessage(); if (message == null || message.length() == 0) { message = cause.toString(); } MessageEOFException exception = new MessageEOFException(message); if (cause instanceof Exception) { exception.setLinkedException((Exception) cause); } exception.initCause(cause); return exception; } static JMSException create(String message, Throwable cause); static JMSException create(Throwable cause); static MessageEOFException createMessageEOFException(Throwable cause); static MessageFormatException createMessageFormatException(Throwable cause); static JMSRuntimeException createRuntimeException(Exception exception); }### Answer:
@Test public void testCreateMessageEOFExceptionFillsMessageFromCauseMessageParamToString() { JMSException result = JMSExceptionSupport.createMessageEOFException(NO_MESSAGE_CAUSE); assertEquals(NO_MESSAGE_CAUSE.toString(), result.getMessage()); }
@Test public void testCreateMessageEOFExceptionFillsMessageFromCauseMessageParamToStringWhenMessageIsEmpty() { JMSException result = JMSExceptionSupport.createMessageEOFException(EMPTY_MESSAGE_CAUSE); assertEquals(EMPTY_MESSAGE_CAUSE.toString(), result.getMessage()); }
@Test public void testCreateMessageEOFExceptionAssignsLinkedException() { JMSException result = JMSExceptionSupport.createMessageEOFException(new IOException(CAUSE_MESSAGE)); assertNotNull(result.getLinkedException()); }
@Test public void testCreateMessageEOFExceptionDoesNotFillLinkedExceptionWhenGivenNonExceptionThrowable() { JMSException result = JMSExceptionSupport.createMessageEOFException(new AssertionError(CAUSE_MESSAGE)); assertNull(result.getLinkedException()); } |
### Question:
JMSMessagePropertySupport { public static void checkPropertyNameIsValid(String propertyName, boolean validateNames) throws IllegalArgumentException { if (propertyName == null) { throw new IllegalArgumentException("Property name must not be null"); } else if (propertyName.length() == 0) { throw new IllegalArgumentException("Property name must not be the empty string"); } if (validateNames) { checkIdentifierLetterAndDigitRequirements(propertyName); checkIdentifierIsntNullTrueFalse(propertyName); checkIdentifierIsntLogicOperator(propertyName); } } @SuppressWarnings("unchecked") static T convertPropertyTo(String name, Object value, Class<T> target); static void checkPropertyNameIsValid(String propertyName, boolean validateNames); static void checkIdentifierIsntLogicOperator(String identifier); static void checkIdentifierIsntNullTrueFalse(String identifier); static void checkIdentifierLetterAndDigitRequirements(String identifier); static void checkValidObject(Object value); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testCheckPropertyNameIsValidWithNullName() throws JMSException { JMSMessagePropertySupport.checkPropertyNameIsValid(null, true); }
@Test(expected = IllegalArgumentException.class) public void testCheckPropertyNameIsValidWithEmptyName() throws JMSException { JMSMessagePropertySupport.checkPropertyNameIsValid("", true); }
@Test public void testCheckPropertyNameWithLogicOperatorValidationDisabled() throws JMSException { JMSMessagePropertySupport.checkPropertyNameIsValid("OR", false); } |
### Question:
JMSMessagePropertySupport { public static void checkIdentifierIsntNullTrueFalse(String identifier) { if ("NULL".equals(identifier) || "TRUE".equals(identifier) || "FALSE".equals(identifier)) { throw new IllegalArgumentException("Identifier not allowed in JMS: '" + identifier + "'"); } } @SuppressWarnings("unchecked") static T convertPropertyTo(String name, Object value, Class<T> target); static void checkPropertyNameIsValid(String propertyName, boolean validateNames); static void checkIdentifierIsntLogicOperator(String identifier); static void checkIdentifierIsntNullTrueFalse(String identifier); static void checkIdentifierLetterAndDigitRequirements(String identifier); static void checkValidObject(Object value); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testCheckIdentifierIsntNullTrueFalseFalse() throws JMSException { JMSMessagePropertySupport.checkIdentifierIsntNullTrueFalse("FALSE"); }
@Test(expected = IllegalArgumentException.class) public void testCheckIdentifierIsntNullTrueFalseNull() throws JMSException { JMSMessagePropertySupport.checkIdentifierIsntNullTrueFalse("NULL"); }
@Test(expected = IllegalArgumentException.class) public void testCheckIdentifierIsntNullTrueFalseTrue() throws JMSException { JMSMessagePropertySupport.checkIdentifierIsntNullTrueFalse("TRUE"); } |
### Question:
JMSMessagePropertySupport { public static void checkIdentifierLetterAndDigitRequirements(String identifier) { char startChar = identifier.charAt(0); if (!(Character.isJavaIdentifierStart(startChar))) { throw new IllegalArgumentException("Identifier does not begin with a valid JMS identifier start character: '" + identifier + "' "); } int length = identifier.length(); for (int i = 1; i < length; i++) { char ch = identifier.charAt(i); if (!(Character.isJavaIdentifierPart(ch))) { throw new IllegalArgumentException("Identifier contains invalid JMS identifier character '" + ch + "': '" + identifier + "' "); } } } @SuppressWarnings("unchecked") static T convertPropertyTo(String name, Object value, Class<T> target); static void checkPropertyNameIsValid(String propertyName, boolean validateNames); static void checkIdentifierIsntLogicOperator(String identifier); static void checkIdentifierIsntNullTrueFalse(String identifier); static void checkIdentifierLetterAndDigitRequirements(String identifier); static void checkValidObject(Object value); }### Answer:
@Test public void testCheckIdentifierLetterAndDigitRequirementsValid() throws JMSException { JMSMessagePropertySupport.checkIdentifierLetterAndDigitRequirements("test"); }
@Test(expected = IllegalArgumentException.class) public void testCheckIdentifierLetterAndDigitRequirementsStartWithNumber() throws JMSException { JMSMessagePropertySupport.checkIdentifierLetterAndDigitRequirements("1"); }
@Test(expected = IllegalArgumentException.class) public void testCheckIdentifierLetterAndDigitRequirementsContainsColon() throws JMSException { JMSMessagePropertySupport.checkIdentifierLetterAndDigitRequirements("a:b"); }
@Test(expected = IllegalArgumentException.class) public void testCheckIdentifierLetterAndDigitRequirementsContainsEndWithColon() throws JMSException { JMSMessagePropertySupport.checkIdentifierLetterAndDigitRequirements("a:b"); } |
### Question:
JmsPoolMessageProducer implements MessageProducer, AutoCloseable { @Override public String toString() { return getClass().getSimpleName() + " { " + messageProducer + " }"; } JmsPoolMessageProducer(JmsPoolSession session, MessageProducer messageProducer, Destination destination, AtomicInteger refCount); @Override void close(); @Override void send(Message message); @Override void send(Message message, int deliveryMode, int priority, long timeToLive); @Override void send(Destination destination, Message message); @Override void send(Destination destination, Message message, int deliveryMode, int priority, long timeToLive); @Override void send(Message message, CompletionListener listener); @Override void send(Message message, int deliveryMode, int priority, long timeToLive, CompletionListener listener); @Override void send(Destination destination, Message message, CompletionListener listener); @Override void send(Destination destination, Message message, int deliveryMode, int priority, long timeToLive, CompletionListener listener); @Override Destination getDestination(); @Override int getDeliveryMode(); @Override void setDeliveryMode(int deliveryMode); @Override boolean getDisableMessageID(); @Override void setDisableMessageID(boolean disableMessageID); @Override boolean getDisableMessageTimestamp(); @Override void setDisableMessageTimestamp(boolean disableMessageTimestamp); @Override int getPriority(); @Override void setPriority(int priority); @Override long getTimeToLive(); @Override void setTimeToLive(long timeToLive); @Override long getDeliveryDelay(); @Override void setDeliveryDelay(long deliveryDelay); @Override String toString(); MessageProducer getMessageProducer(); boolean isAnonymousProducer(); AtomicInteger getRefCount(); MessageProducer getDelegate(); Destination getDelegateDestination(); }### Answer:
@Test public void testToString() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageProducer producer = session.createProducer(queue); assertNotNull(producer.toString()); } |
### Question:
JmsPoolMessageProducer implements MessageProducer, AutoCloseable { @Override public void close() throws JMSException { doClose(false); } JmsPoolMessageProducer(JmsPoolSession session, MessageProducer messageProducer, Destination destination, AtomicInteger refCount); @Override void close(); @Override void send(Message message); @Override void send(Message message, int deliveryMode, int priority, long timeToLive); @Override void send(Destination destination, Message message); @Override void send(Destination destination, Message message, int deliveryMode, int priority, long timeToLive); @Override void send(Message message, CompletionListener listener); @Override void send(Message message, int deliveryMode, int priority, long timeToLive, CompletionListener listener); @Override void send(Destination destination, Message message, CompletionListener listener); @Override void send(Destination destination, Message message, int deliveryMode, int priority, long timeToLive, CompletionListener listener); @Override Destination getDestination(); @Override int getDeliveryMode(); @Override void setDeliveryMode(int deliveryMode); @Override boolean getDisableMessageID(); @Override void setDisableMessageID(boolean disableMessageID); @Override boolean getDisableMessageTimestamp(); @Override void setDisableMessageTimestamp(boolean disableMessageTimestamp); @Override int getPriority(); @Override void setPriority(int priority); @Override long getTimeToLive(); @Override void setTimeToLive(long timeToLive); @Override long getDeliveryDelay(); @Override void setDeliveryDelay(long deliveryDelay); @Override String toString(); MessageProducer getMessageProducer(); boolean isAnonymousProducer(); AtomicInteger getRefCount(); MessageProducer getDelegate(); Destination getDelegateDestination(); }### Answer:
@Test public void testCloseMoreThanOnce() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageProducer producer = session.createProducer(queue); producer.close(); producer.close(); } |
### Question:
JmsPoolQueueSender extends JmsPoolMessageProducer implements QueueSender, AutoCloseable { @Override public String toString() { return getClass().getSimpleName() + " { " + getDelegate() + " }"; } JmsPoolQueueSender(JmsPoolSession session, QueueSender messageProducer, Destination destination, AtomicInteger refCount); @Override void send(Queue queue, Message message, int deliveryMode, int priority, long timeToLine); @Override void send(Queue queue, Message message); @Override Queue getQueue(); @Override String toString(); QueueSender getQueueSender(); }### Answer:
@Test public void testToString() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createTemporaryQueue(); QueueSender sender = session.createSender(queue); assertNotNull(sender.toString()); } |
### Question:
JmsPoolQueueSender extends JmsPoolMessageProducer implements QueueSender, AutoCloseable { @Override public Queue getQueue() throws JMSException { return (Queue) getDestination(); } JmsPoolQueueSender(JmsPoolSession session, QueueSender messageProducer, Destination destination, AtomicInteger refCount); @Override void send(Queue queue, Message message, int deliveryMode, int priority, long timeToLine); @Override void send(Queue queue, Message message); @Override Queue getQueue(); @Override String toString(); QueueSender getQueueSender(); }### Answer:
@Test public void testGetQueue() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createTemporaryQueue(); QueueSender sender = session.createSender(queue); assertNotNull(sender.getQueue()); assertSame(queue, sender.getQueue()); sender.close(); try { sender.getQueue(); fail("Cannot read topic on closed sender"); } catch (IllegalStateException ise) {} } |
### Question:
JmsPoolQueueSender extends JmsPoolMessageProducer implements QueueSender, AutoCloseable { public QueueSender getQueueSender() throws JMSException { return (QueueSender) getMessageProducer(); } JmsPoolQueueSender(JmsPoolSession session, QueueSender messageProducer, Destination destination, AtomicInteger refCount); @Override void send(Queue queue, Message message, int deliveryMode, int priority, long timeToLine); @Override void send(Queue queue, Message message); @Override Queue getQueue(); @Override String toString(); QueueSender getQueueSender(); }### Answer:
@Test public void testGetTopicSubscriber() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createTemporaryQueue(); JmsPoolQueueSender sender = (JmsPoolQueueSender) session.createSender(queue); assertNotNull(sender.getQueueSender()); assertTrue(sender.getQueueSender() instanceof MockJMSQueueSender); sender.close(); try { sender.getQueueSender(); fail("Cannot read state on closed sender"); } catch (IllegalStateException ise) {} } |
### Question:
JmsPoolTopicPublisher extends JmsPoolMessageProducer implements TopicPublisher, AutoCloseable { @Override public String toString() { return getClass().getSimpleName() + " { " + getDelegate() + " }"; } JmsPoolTopicPublisher(JmsPoolSession session, TopicPublisher messageProducer, Destination destination, AtomicInteger refCount); @Override Topic getTopic(); @Override void publish(Message message); @Override void publish(Message message, int deliveryMode, int priority, long timeToLive); @Override void publish(Topic topic, Message message); @Override void publish(Topic topic, Message message, int deliveryMode, int priority, long timeToLive); @Override String toString(); TopicPublisher getTopicPublisher(); }### Answer:
@Test public void testToString() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createTopicConnection(); TopicSession session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE); Topic topic = session.createTemporaryTopic(); TopicPublisher publisher = session.createPublisher(topic); assertNotNull(publisher.toString()); } |
### Question:
JmsPoolTopicPublisher extends JmsPoolMessageProducer implements TopicPublisher, AutoCloseable { @Override public Topic getTopic() throws JMSException { return (Topic) getDestination(); } JmsPoolTopicPublisher(JmsPoolSession session, TopicPublisher messageProducer, Destination destination, AtomicInteger refCount); @Override Topic getTopic(); @Override void publish(Message message); @Override void publish(Message message, int deliveryMode, int priority, long timeToLive); @Override void publish(Topic topic, Message message); @Override void publish(Topic topic, Message message, int deliveryMode, int priority, long timeToLive); @Override String toString(); TopicPublisher getTopicPublisher(); }### Answer:
@Test public void testGetTopic() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createTopicConnection(); TopicSession session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE); Topic topic = session.createTemporaryTopic(); TopicPublisher publisher = session.createPublisher(topic); assertNotNull(publisher.getTopic()); assertSame(topic, publisher.getTopic()); publisher.close(); try { publisher.getTopic(); fail("Cannot read topic on closed publisher"); } catch (IllegalStateException ise) {} } |
### Question:
JmsPoolTopicPublisher extends JmsPoolMessageProducer implements TopicPublisher, AutoCloseable { public TopicPublisher getTopicPublisher() throws JMSException { return (TopicPublisher) getMessageProducer(); } JmsPoolTopicPublisher(JmsPoolSession session, TopicPublisher messageProducer, Destination destination, AtomicInteger refCount); @Override Topic getTopic(); @Override void publish(Message message); @Override void publish(Message message, int deliveryMode, int priority, long timeToLive); @Override void publish(Topic topic, Message message); @Override void publish(Topic topic, Message message, int deliveryMode, int priority, long timeToLive); @Override String toString(); TopicPublisher getTopicPublisher(); }### Answer:
@Test public void testGetTopicPublisher() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createTopicConnection(); TopicSession session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE); Topic topic = session.createTemporaryTopic(); JmsPoolTopicPublisher publisher = (JmsPoolTopicPublisher) session.createPublisher(topic); assertNotNull(publisher.getTopicPublisher()); assertTrue(publisher.getTopicPublisher() instanceof MockJMSTopicPublisher); publisher.close(); try { publisher.getTopicPublisher(); fail("Cannot read state on closed publisher"); } catch (IllegalStateException ise) {} } |
### Question:
JmsPoolJMSConsumer implements JMSConsumer, AutoCloseable { @Override public String toString() { return getClass().getSimpleName() + " { " + consumer + " }"; } JmsPoolJMSConsumer(JmsPoolMessageConsumer consumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override void setMessageListener(MessageListener listener); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override T receiveBody(Class<T> desired); @Override T receiveBody(Class<T> desired, long timeout); @Override T receiveBodyNoWait(Class<T> desired); @Override String toString(); }### Answer:
@Test(timeout = 30000) public void testToString() throws JMSException { JMSConsumer consumer = context.createConsumer(context.createTemporaryQueue()); assertNotNull(consumer.toString()); } |
### Question:
JmsPoolJMSConsumer implements JMSConsumer, AutoCloseable { @Override public void close() { try { consumer.close(); } catch (JMSException e) { throw JMSExceptionSupport.createRuntimeException(e); } } JmsPoolJMSConsumer(JmsPoolMessageConsumer consumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override void setMessageListener(MessageListener listener); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override T receiveBody(Class<T> desired); @Override T receiveBody(Class<T> desired, long timeout); @Override T receiveBodyNoWait(Class<T> desired); @Override String toString(); }### Answer:
@Test public void testCloseMoreThanOnce() throws JMSException { JMSConsumer consumer = context.createConsumer(context.createTemporaryQueue()); consumer.close(); consumer.close(); }
@Test public void testJMSExOnConsumerCloseConvertedToJMSREx() throws JMSException { JMSConsumer consumer = context.createConsumer(context.createTemporaryQueue()); MockJMSConnection connection = (MockJMSConnection) context.getConnection(); connection.addConnectionListener(new MockJMSDefaultConnectionListener() { @Override public void onCloseMessageConsumer(MockJMSSession session, MockJMSMessageConsumer consumer) throws JMSException { throw new IllegalStateException("Some failure"); } }); try { consumer.close(); fail("Should throw on wrapped consumer throw"); } catch (IllegalStateRuntimeException isre) {} } |
### Question:
JmsPoolJMSConsumer implements JMSConsumer, AutoCloseable { @Override public Message receive() { try { return consumer.receive(); } catch (JMSException e) { throw JMSExceptionSupport.createRuntimeException(e); } } JmsPoolJMSConsumer(JmsPoolMessageConsumer consumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override void setMessageListener(MessageListener listener); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override T receiveBody(Class<T> desired); @Override T receiveBody(Class<T> desired, long timeout); @Override T receiveBodyNoWait(Class<T> desired); @Override String toString(); }### Answer:
@Test public void testReceive() throws JMSException { JMSConsumer consumer = context.createConsumer(context.createTemporaryQueue()); assertNull(consumer.receive()); consumer.close(); try { consumer.receive(); fail("Should not be able to interact with closed consumer"); } catch (IllegalStateRuntimeException ise) {} } |
### Question:
JmsPoolJMSConsumer implements JMSConsumer, AutoCloseable { @Override public Message receiveNoWait() { try { return consumer.receiveNoWait(); } catch (JMSException e) { throw JMSExceptionSupport.createRuntimeException(e); } } JmsPoolJMSConsumer(JmsPoolMessageConsumer consumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override void setMessageListener(MessageListener listener); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override T receiveBody(Class<T> desired); @Override T receiveBody(Class<T> desired, long timeout); @Override T receiveBodyNoWait(Class<T> desired); @Override String toString(); }### Answer:
@Test public void testReceiveNoWait() throws JMSException { JMSConsumer consumer = context.createConsumer(context.createTemporaryQueue()); assertNull(consumer.receiveNoWait()); consumer.close(); try { consumer.receiveNoWait(); fail("Should not be able to interact with closed consumer"); } catch (IllegalStateRuntimeException ise) {} } |
### Question:
JmsPoolJMSConsumer implements JMSConsumer, AutoCloseable { @Override public String getMessageSelector() { try { return consumer.getMessageSelector(); } catch (JMSException e) { throw JMSExceptionSupport.createRuntimeException(e); } } JmsPoolJMSConsumer(JmsPoolMessageConsumer consumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override void setMessageListener(MessageListener listener); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override T receiveBody(Class<T> desired); @Override T receiveBody(Class<T> desired, long timeout); @Override T receiveBodyNoWait(Class<T> desired); @Override String toString(); }### Answer:
@Test public void testGetMessageSelector() throws JMSException { JMSConsumer consumer = context.createConsumer(context.createTemporaryQueue(), "Color = Red"); assertNotNull(consumer.getMessageSelector()); assertEquals("Color = Red", consumer.getMessageSelector()); consumer.close(); try { consumer.getMessageSelector(); fail("Should not be able to interact with closed consumer"); } catch (IllegalStateRuntimeException ise) {} } |
### Question:
JmsPoolJMSConsumer implements JMSConsumer, AutoCloseable { @Override public void setMessageListener(MessageListener listener) { try { consumer.setMessageListener(listener); } catch (JMSException e) { throw JMSExceptionSupport.createRuntimeException(e); } } JmsPoolJMSConsumer(JmsPoolMessageConsumer consumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override void setMessageListener(MessageListener listener); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override T receiveBody(Class<T> desired); @Override T receiveBody(Class<T> desired, long timeout); @Override T receiveBodyNoWait(Class<T> desired); @Override String toString(); }### Answer:
@Test public void testSetMessageListener() throws JMSException { JMSConsumer consumer = context.createConsumer(context.createTemporaryQueue()); MessageListener listener = new MessageListener() { @Override public void onMessage(Message message) { } }; assertNull(consumer.getMessageListener()); consumer.setMessageListener(listener); assertNotNull(consumer.getMessageListener()); assertEquals(listener, consumer.getMessageListener()); consumer.close(); try { consumer.setMessageListener(null); fail("Should not be able to interact with closed consumer"); } catch (IllegalStateRuntimeException ise) {} try { consumer.getMessageListener(); fail("Should not be able to interact with closed consumer"); } catch (IllegalStateRuntimeException ise) {} } |
### Question:
JmsPoolJMSConsumer implements JMSConsumer, AutoCloseable { @Override public <T> T receiveBody(Class<T> desired) { throw new JMSRuntimeException("Pooled JMSConsumer does not support receiveBody"); } JmsPoolJMSConsumer(JmsPoolMessageConsumer consumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override void setMessageListener(MessageListener listener); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override T receiveBody(Class<T> desired); @Override T receiveBody(Class<T> desired, long timeout); @Override T receiveBodyNoWait(Class<T> desired); @Override String toString(); }### Answer:
@Test public void testReceiveBody() throws JMSException { JMSConsumer consumer = context.createConsumer(context.createTemporaryQueue()); try { consumer.receiveBody(String.class); fail("Should not be able to interact with closed consumer"); } catch (JMSRuntimeException ise) {} }
@Test public void testReceiveBodyTimed() throws JMSException { JMSConsumer consumer = context.createConsumer(context.createTemporaryQueue()); try { consumer.receiveBody(String.class, 1); fail("Should not be able to interact with closed consumer"); } catch (JMSRuntimeException ise) {} } |
### Question:
JmsPoolJMSConsumer implements JMSConsumer, AutoCloseable { @Override public <T> T receiveBodyNoWait(Class<T> desired) { throw new JMSRuntimeException("Pooled JMSConsumer does not support receiveBody"); } JmsPoolJMSConsumer(JmsPoolMessageConsumer consumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override void setMessageListener(MessageListener listener); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override T receiveBody(Class<T> desired); @Override T receiveBody(Class<T> desired, long timeout); @Override T receiveBodyNoWait(Class<T> desired); @Override String toString(); }### Answer:
@Test public void testReceiveBodyNoWait() throws JMSException { JMSConsumer consumer = context.createConsumer(context.createTemporaryQueue()); try { consumer.receiveBodyNoWait(String.class); fail("Should not be able to interact with closed consumer"); } catch (JMSRuntimeException ise) {} } |
### Question:
JmsPoolConnectionFactory implements ConnectionFactory, QueueConnectionFactory, TopicConnectionFactory { public Object getConnectionFactory() { return connectionFactory; } void initConnectionsPool(); Object getConnectionFactory(); void setConnectionFactory(final Object factory); @Override QueueConnection createQueueConnection(); @Override QueueConnection createQueueConnection(String userName, String password); @Override TopicConnection createTopicConnection(); @Override TopicConnection createTopicConnection(String userName, String password); @Override Connection createConnection(); @Override Connection createConnection(String userName, String password); @Override JMSContext createContext(); @Override JMSContext createContext(int sessionMode); @Override JMSContext createContext(String username, String password); @Override JMSContext createContext(String username, String password, int sessionMode); void start(); void stop(); void clear(); int getMaxSessionsPerConnection(); void setMaxSessionsPerConnection(int maxSessionsPerConnection); void setBlockIfSessionPoolIsFull(boolean block); boolean isBlockIfSessionPoolIsFull(); int getMaxConnections(); void setMaxConnections(int maxConnections); int getConnectionIdleTimeout(); void setConnectionIdleTimeout(int connectionIdleTimeout); boolean isUseAnonymousProducers(); void setUseAnonymousProducers(boolean value); int getExplicitProducerCacheSize(); void setExplicitProducerCacheSize(int cacheSize); void setConnectionCheckInterval(long connectionCheckInterval); long getConnectionCheckInterval(); int getNumConnections(); long getBlockIfSessionPoolIsFullTimeout(); void setBlockIfSessionPoolIsFullTimeout(long blockIfSessionPoolIsFullTimeout); boolean isUseProviderJMSContext(); void setUseProviderJMSContext(boolean useProviderJMSContext); static final int DEFAULT_MAX_CONNECTIONS; }### Answer:
@Test(timeout = 60000) public void testGetConnectionFactory() throws Exception { cf = new JmsPoolConnectionFactory(); assertNull("Should not have any factory set yet", cf.getConnectionFactory()); cf.setConnectionFactory(factory); assertNotNull("Should have a factory set yet", cf.getConnectionFactory()); assertSame(factory, cf.getConnectionFactory()); } |
### Question:
JmsPoolConnectionFactory implements ConnectionFactory, QueueConnectionFactory, TopicConnectionFactory { @Override public Connection createConnection() throws JMSException { return createConnection(null, null); } void initConnectionsPool(); Object getConnectionFactory(); void setConnectionFactory(final Object factory); @Override QueueConnection createQueueConnection(); @Override QueueConnection createQueueConnection(String userName, String password); @Override TopicConnection createTopicConnection(); @Override TopicConnection createTopicConnection(String userName, String password); @Override Connection createConnection(); @Override Connection createConnection(String userName, String password); @Override JMSContext createContext(); @Override JMSContext createContext(int sessionMode); @Override JMSContext createContext(String username, String password); @Override JMSContext createContext(String username, String password, int sessionMode); void start(); void stop(); void clear(); int getMaxSessionsPerConnection(); void setMaxSessionsPerConnection(int maxSessionsPerConnection); void setBlockIfSessionPoolIsFull(boolean block); boolean isBlockIfSessionPoolIsFull(); int getMaxConnections(); void setMaxConnections(int maxConnections); int getConnectionIdleTimeout(); void setConnectionIdleTimeout(int connectionIdleTimeout); boolean isUseAnonymousProducers(); void setUseAnonymousProducers(boolean value); int getExplicitProducerCacheSize(); void setExplicitProducerCacheSize(int cacheSize); void setConnectionCheckInterval(long connectionCheckInterval); long getConnectionCheckInterval(); int getNumConnections(); long getBlockIfSessionPoolIsFullTimeout(); void setBlockIfSessionPoolIsFullTimeout(long blockIfSessionPoolIsFullTimeout); boolean isUseProviderJMSContext(); void setUseProviderJMSContext(boolean useProviderJMSContext); static final int DEFAULT_MAX_CONNECTIONS; }### Answer:
@Test(expected = IllegalStateException.class) public void testCreateConnectionWithNoFactorySet() throws Exception { cf = new JmsPoolConnectionFactory(); cf.createConnection(); }
@Test(timeout = 60000) public void testCreateConnection() throws Exception { Connection connection = cf.createConnection(); assertNotNull(connection); assertEquals(1, cf.getNumConnections()); connection.close(); assertEquals(1, cf.getNumConnections()); } |
### Question:
JmsPoolMessageConsumer implements MessageConsumer, AutoCloseable { @Override public String toString() { return getClass().getSimpleName() + " { " + messageConsumer + " }"; } JmsPoolMessageConsumer(JmsPoolSession session, MessageConsumer messageConsumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override void setMessageListener(MessageListener listener); @Override String toString(); MessageConsumer getMessageConsumer(); }### Answer:
@Test public void testToString() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageConsumer consumer = session.createConsumer(queue); assertNotNull(consumer.toString()); } |
### Question:
JmsPoolMessageConsumer implements MessageConsumer, AutoCloseable { @Override public void close() throws JMSException { if (closed.compareAndSet(false, true)) { session.onConsumerClose(messageConsumer); messageConsumer.close(); } } JmsPoolMessageConsumer(JmsPoolSession session, MessageConsumer messageConsumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override void setMessageListener(MessageListener listener); @Override String toString(); MessageConsumer getMessageConsumer(); }### Answer:
@Test public void testCloseMoreThanOnce() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageConsumer consumer = session.createConsumer(queue); consumer.close(); consumer.close(); } |
### Question:
JmsPoolMessageConsumer implements MessageConsumer, AutoCloseable { @Override public Message receive() throws JMSException { checkClosed(); return messageConsumer.receive(); } JmsPoolMessageConsumer(JmsPoolSession session, MessageConsumer messageConsumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override void setMessageListener(MessageListener listener); @Override String toString(); MessageConsumer getMessageConsumer(); }### Answer:
@Test public void testReceive() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageConsumer consumer = session.createConsumer(queue, "Color = Red"); assertNull(consumer.receive()); consumer.close(); try { consumer.receive(); fail("Should not be able to interact with closed consumer"); } catch (IllegalStateException ise) {} } |
### Question:
JmsPoolMessageConsumer implements MessageConsumer, AutoCloseable { @Override public Message receiveNoWait() throws JMSException { checkClosed(); return messageConsumer.receiveNoWait(); } JmsPoolMessageConsumer(JmsPoolSession session, MessageConsumer messageConsumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override void setMessageListener(MessageListener listener); @Override String toString(); MessageConsumer getMessageConsumer(); }### Answer:
@Test public void testReceiveNoWait() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageConsumer consumer = session.createConsumer(queue, "Color = Red"); assertNull(consumer.receiveNoWait()); consumer.close(); try { consumer.receiveNoWait(); fail("Should not be able to interact with closed consumer"); } catch (IllegalStateException ise) {} } |
### Question:
JmsPoolMessageConsumer implements MessageConsumer, AutoCloseable { @Override public String getMessageSelector() throws JMSException { checkClosed(); return messageConsumer.getMessageSelector(); } JmsPoolMessageConsumer(JmsPoolSession session, MessageConsumer messageConsumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override void setMessageListener(MessageListener listener); @Override String toString(); MessageConsumer getMessageConsumer(); }### Answer:
@Test public void testGetMessageSelector() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageConsumer consumer = session.createConsumer(queue, "Color = Red"); assertNotNull(consumer.getMessageSelector()); assertEquals("Color = Red", consumer.getMessageSelector()); consumer.close(); try { consumer.getMessageSelector(); fail("Should not be able to interact with closed consumer"); } catch (IllegalStateException ise) {} } |
### Question:
JmsPoolMessageConsumer implements MessageConsumer, AutoCloseable { @Override public void setMessageListener(MessageListener listener) throws JMSException { checkClosed(); messageConsumer.setMessageListener(listener); } JmsPoolMessageConsumer(JmsPoolSession session, MessageConsumer messageConsumer); @Override void close(); @Override MessageListener getMessageListener(); @Override String getMessageSelector(); @Override Message receive(); @Override Message receive(long timeout); @Override Message receiveNoWait(); @Override void setMessageListener(MessageListener listener); @Override String toString(); MessageConsumer getMessageConsumer(); }### Answer:
@Test public void testSetMessageListener() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageConsumer consumer = session.createConsumer(queue); MessageListener listener = new MessageListener() { @Override public void onMessage(Message message) { } }; assertNull(consumer.getMessageListener()); consumer.setMessageListener(listener); assertNotNull(consumer.getMessageListener()); assertEquals(listener, consumer.getMessageListener()); consumer.close(); try { consumer.setMessageListener(null); fail("Should not be able to interact with closed consumer"); } catch (IllegalStateException ise) {} try { consumer.getMessageListener(); fail("Should not be able to interact with closed consumer"); } catch (IllegalStateException ise) {} } |
### Question:
JmsPoolConnection implements TopicConnection, QueueConnection, JmsPoolSessionEventListener, AutoCloseable { @Override public ConnectionMetaData getMetaData() throws JMSException { return getConnection().getMetaData(); } JmsPoolConnection(PooledConnection pool); @Override void close(); @Override void start(); @Override void stop(); @Override ConnectionMetaData getMetaData(); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener exceptionListener); @Override String getClientID(); @Override void setClientID(String clientID); @Override ConnectionConsumer createConnectionConsumer(Destination destination, String selector, ServerSessionPool serverSessionPool, int maxMessages); @Override ConnectionConsumer createConnectionConsumer(Topic topic, String s, ServerSessionPool serverSessionPool, int maxMessages); @Override ConnectionConsumer createDurableConnectionConsumer(Topic topic, String selector, String s1, ServerSessionPool serverSessionPool, int i); @Override ConnectionConsumer createSharedDurableConnectionConsumer(Topic topic, String subscriptionName, String selector, ServerSessionPool sessionPool, int maxMessages); @Override ConnectionConsumer createSharedConnectionConsumer(Topic topic, String subscriptionName, String selector, ServerSessionPool sessionPool, int maxMessages); @Override ConnectionConsumer createConnectionConsumer(Queue queue, String selector, ServerSessionPool serverSessionPool, int maxMessages); @Override QueueSession createQueueSession(boolean transacted, int ackMode); @Override TopicSession createTopicSession(boolean transacted, int ackMode); @Override Session createSession(); @Override Session createSession(int sessionMode); @Override Session createSession(boolean transacted, int ackMode); @Override void onTemporaryQueueCreate(TemporaryQueue tempQueue); @Override void onTemporaryTopicCreate(TemporaryTopic tempTopic); @Override void onSessionClosed(JmsPoolSession session); Connection getConnection(); @Override String toString(); int getNumSessions(); int getNumActiveSessions(); int getNumtIdleSessions(); }### Answer:
@Test(timeout = 60000) public void testGetConnectionMetaData() throws Exception { Connection connection = cf.createConnection(); assertNotNull(connection.getMetaData()); } |
### Question:
JmsPoolTopicSubscriber extends JmsPoolMessageConsumer implements TopicSubscriber, AutoCloseable { @Override public String toString() { return getClass().getSimpleName() + " { " + getDelegate() + " }"; } JmsPoolTopicSubscriber(JmsPoolSession session, TopicSubscriber delegate); @Override Topic getTopic(); @Override boolean getNoLocal(); @Override String toString(); TopicSubscriber getTopicSubscriber(); }### Answer:
@Test public void testToString() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createTopicConnection(); TopicSession session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE); Topic topic = session.createTemporaryTopic(); TopicSubscriber subscriber = session.createSubscriber(topic); assertNotNull(subscriber.toString()); } |
### Question:
JmsPoolTopicSubscriber extends JmsPoolMessageConsumer implements TopicSubscriber, AutoCloseable { @Override public Topic getTopic() throws JMSException { return getTopicSubscriber().getTopic(); } JmsPoolTopicSubscriber(JmsPoolSession session, TopicSubscriber delegate); @Override Topic getTopic(); @Override boolean getNoLocal(); @Override String toString(); TopicSubscriber getTopicSubscriber(); }### Answer:
@Test public void testGetTopic() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createTopicConnection(); TopicSession session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE); Topic topic = session.createTemporaryTopic(); TopicSubscriber subscriber = session.createSubscriber(topic); assertNotNull(subscriber.getTopic()); assertSame(topic, subscriber.getTopic()); subscriber.close(); try { subscriber.getTopic(); fail("Cannot read topic on closed subscriber"); } catch (IllegalStateException ise) {} } |
### Question:
JmsPoolTopicSubscriber extends JmsPoolMessageConsumer implements TopicSubscriber, AutoCloseable { @Override public boolean getNoLocal() throws JMSException { return getTopicSubscriber().getNoLocal(); } JmsPoolTopicSubscriber(JmsPoolSession session, TopicSubscriber delegate); @Override Topic getTopic(); @Override boolean getNoLocal(); @Override String toString(); TopicSubscriber getTopicSubscriber(); }### Answer:
@Test public void testGetNoLocal() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createTopicConnection(); TopicSession session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE); Topic topic = session.createTemporaryTopic(); TopicSubscriber subscriber = session.createDurableSubscriber(topic, "name", "color = red", true); assertTrue(subscriber.getNoLocal()); subscriber.close(); try { subscriber.getNoLocal(); fail("Cannot read state on closed subscriber"); } catch (IllegalStateException ise) {} } |
### Question:
JmsPoolTopicSubscriber extends JmsPoolMessageConsumer implements TopicSubscriber, AutoCloseable { public TopicSubscriber getTopicSubscriber() throws JMSException { return (TopicSubscriber) super.getMessageConsumer(); } JmsPoolTopicSubscriber(JmsPoolSession session, TopicSubscriber delegate); @Override Topic getTopic(); @Override boolean getNoLocal(); @Override String toString(); TopicSubscriber getTopicSubscriber(); }### Answer:
@Test public void testGetTopicSubscriber() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createTopicConnection(); TopicSession session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE); Topic topic = session.createTemporaryTopic(); JmsPoolTopicSubscriber subscriber = (JmsPoolTopicSubscriber) session.createDurableSubscriber(topic, "name", "color = red", true); assertNotNull(subscriber.getTopicSubscriber()); assertTrue(subscriber.getTopicSubscriber() instanceof MockJMSTopicSubscriber); subscriber.close(); try { subscriber.getTopicSubscriber(); fail("Cannot read state on closed subscriber"); } catch (IllegalStateException ise) {} } |
### Question:
JmsPoolQueueReceiver extends JmsPoolMessageConsumer implements QueueReceiver, AutoCloseable { @Override public String toString() { return getClass().getSimpleName() + " { " + getDelegate() + " }"; } JmsPoolQueueReceiver(JmsPoolSession session, QueueReceiver delegate); @Override Queue getQueue(); @Override String toString(); QueueReceiver getQueueReceiver(); }### Answer:
@Test public void testToString() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createTemporaryQueue(); QueueReceiver receiver = session.createReceiver(queue); assertNotNull(receiver.toString()); } |
### Question:
JmsPoolQueueReceiver extends JmsPoolMessageConsumer implements QueueReceiver, AutoCloseable { @Override public Queue getQueue() throws JMSException { return getQueueReceiver().getQueue(); } JmsPoolQueueReceiver(JmsPoolSession session, QueueReceiver delegate); @Override Queue getQueue(); @Override String toString(); QueueReceiver getQueueReceiver(); }### Answer:
@Test public void testGetQueue() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createTemporaryQueue(); QueueReceiver receiver = session.createReceiver(queue); assertNotNull(receiver.getQueue()); assertSame(queue, receiver.getQueue()); receiver.close(); try { receiver.getQueue(); fail("Cannot read topic on closed receiver"); } catch (IllegalStateException ise) {} } |
### Question:
JmsPoolQueueReceiver extends JmsPoolMessageConsumer implements QueueReceiver, AutoCloseable { public QueueReceiver getQueueReceiver() throws JMSException { return (QueueReceiver) super.getMessageConsumer(); } JmsPoolQueueReceiver(JmsPoolSession session, QueueReceiver delegate); @Override Queue getQueue(); @Override String toString(); QueueReceiver getQueueReceiver(); }### Answer:
@Test public void testGetTopicSubscriber() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createTemporaryQueue(); JmsPoolQueueReceiver receiver = (JmsPoolQueueReceiver) session.createReceiver(queue); assertNotNull(receiver.getQueueReceiver()); assertTrue(receiver.getQueueReceiver() instanceof MockJMSQueueReceiver); receiver.close(); try { receiver.getQueueReceiver(); fail("Cannot read state on closed receiver"); } catch (IllegalStateException ise) {} } |
### Question:
DigestUtils { public static byte[] digest(MessageDigest digest, byte[] data) { return digest.digest(data); } static byte[] digest(MessageDigest digest, byte[] data); static MessageDigest updateDigest(MessageDigest messageDigest, byte[] valueToDigest); static byte[] digest(MessageDigest digest, InputStream data); static String getHexString(byte[] data); static byte[] fromHexString(String hexString); static String digest(MessageDigestAlgorithms algorithms, String data); }### Answer:
@Test public void testMd5() { String source = "123456"; PerformanceMonitor.start("DigestUtilsTest"); for (int i = 0; i < 5; i++) { for (int j = 0; j < 10000; j++) { Assert.assertEquals("e10adc3949ba59abbe56e057f20f883e", DigestUtils.digest(MessageDigestAlgorithms.MD5, source)); } PerformanceMonitor.mark("md5 Test"); } for (int i = 0; i < 5; i++) { for (int j = 0; j < 10000; j++) { Assert.assertEquals("7c4a8d09ca3762af61e59520943dc26494f8941b", DigestUtils.digest(MessageDigestAlgorithms.SHA_1, source)); } PerformanceMonitor.mark("sha1 Test"); } PerformanceMonitor.stop(); PerformanceMonitor.summarize(new AdvancedStopWatchSummary(true)); PerformanceMonitor.remove(); } |
### Question:
NumberUtils { public static boolean isPositiveNumber(Number number) { if (number == null) return false; return org.apache.commons.lang3.math.NumberUtils.isDigits(number.toString()) && number.byteValue() > 0; } static int toInt(String str); static long toLong(String str); static float toFloat(String str); static float toFloat(String str, float defaultValue); static double toDouble(String str); static double toDouble(String str, double defaultValue); static Integer createInteger(String str); static Long createLong(String str); static BigInteger createBigInteger(String str); static BigDecimal createBigDecimal(String str); static Float createFloat(String str); static Double createDouble(String str); static boolean isNumber(String str); static boolean isDigits(String str); static boolean isPositiveNumber(Number number); static long min(long[] array); static int min(int[] array); static short min(short[] array); static byte min(byte[] array); static double min(double[] array); static float min(float[] array); static long max(long[] array); static int max(int[] array); static short max(short[] array); static byte max(byte[] array); static double max(double[] array); static float max(float[] array); }### Answer:
@Test public void testIsPositiveNumber() { Assert.assertFalse(NumberUtils.isPositiveNumber(-1L)); Assert.assertFalse(NumberUtils.isPositiveNumber(-10000000000000000L)); Assert.assertFalse(NumberUtils.isPositiveNumber(0)); Assert.assertFalse(NumberUtils.isPositiveNumber(1.6)); Assert.assertTrue(NumberUtils.isPositiveNumber(1)); } |
### Question:
Message { public T getContent() { return content; } Message(MessageType type, T content); MessageType getType(); T getContent(); }### Answer:
@Test public void test() { ApplicationContext applicationContext = BeanFactoryContext.currentApplicationContext(); LOGGER.info(ApplicationContextUtils.getMessage(applicationContext, Locale.CHINA, "helloWorld")); LOGGER.info(ApplicationContextUtils.getMessage(applicationContext, Locale.US, "helloWorld")); if (ApplicationContextUtils.getMessage(applicationContext, Locale.CHINA, "helloWorld1") == null) { LOGGER.info("helloWorld1 is not existsed"); } LOGGER.info(MessageUtils.success("helloWorld").getContent()); } |
### Question:
RepositoryRestApi { @NotNull public OutputResource requestResourceOutput(@NotNull String resourceUri) throws IOException, HttpException { Utils.checkNotNull(resourceUri, "Resource uri should not be null"); HttpUrl url = new PathResolver.Builder() .addPath("rest_v2") .addPath("resources") .addPaths(resourceUri) .build() .resolve(mNetworkClient.getBaseUrl()); Request request = new Request.Builder() .get() .url(url) .build(); com.squareup.okhttp.Response rawResponse = mNetworkClient.makeCall(request); return new RetrofitOutputResource(rawResponse.body()); } RepositoryRestApi(NetworkClient networkClient); @NotNull ResourceSearchResult searchResources(@NotNull Map<String, Object> searchParams); @NotNull ResourceLookup requestResource(@NotNull String resourceUri, @NotNull String type); @NotNull DashboardComponentCollection requestDashboardComponents(@NotNull String dashboardUri); @NotNull OutputResource requestResourceOutput(@NotNull String resourceUri); }### Answer:
@Test public void requestForFileContentShouldNotAcceptNullUri() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Resource uri should not be null"); restApiUnderTest.requestResourceOutput(null); }
@Test public void shouldRequestFileContent() throws Exception { mWebMockRule.enqueue(MockResponseFactory.create200()); restApiUnderTest.requestResourceOutput("/my/uri"); RecordedRequest request = mWebMockRule.get().takeRequest(); assertThat(request, hasPath("/rest_v2/resources/my/uri")); assertThat(request, wasMethod("GET")); } |
### Question:
RepositoryRestApi { @NotNull public DashboardComponentCollection requestDashboardComponents(@NotNull String dashboardUri) throws IOException, HttpException { Utils.checkNotNull(dashboardUri, "Dashboard uri should not be null"); HttpUrl url = new PathResolver.Builder() .addPath("rest_v2") .addPath("resources") .addPaths(dashboardUri + "_files") .addPath("components") .build() .resolve(mNetworkClient.getBaseUrl()) .newBuilder() .addQueryParameter("expanded", "false") .build(); Request request = new Request.Builder() .addHeader("Accept", "application/dashboardComponentsSchema+json") .get() .url(url) .build(); com.squareup.okhttp.Response rawResponse = mNetworkClient.makeCall(request); return mNetworkClient.deserializeJson(rawResponse, DashboardComponentCollection.class); } RepositoryRestApi(NetworkClient networkClient); @NotNull ResourceSearchResult searchResources(@NotNull Map<String, Object> searchParams); @NotNull ResourceLookup requestResource(@NotNull String resourceUri, @NotNull String type); @NotNull DashboardComponentCollection requestDashboardComponents(@NotNull String dashboardUri); @NotNull OutputResource requestResourceOutput(@NotNull String resourceUri); }### Answer:
@Test public void requestForRequestDashboardComponentsdNotAcceptNullUri() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Dashboard uri should not be null"); restApiUnderTest.requestDashboardComponents(null); }
@Test public void shouldRequestDashboardComponents() throws Exception { mWebMockRule.enqueue(MockResponseFactory.create200()); restApiUnderTest.requestDashboardComponents("/my/uri"); RecordedRequest request = mWebMockRule.get().takeRequest(); assertThat(request, containsHeader("Accept", "application/dashboardComponentsSchema+json")); assertThat(request, hasPath("/rest_v2/resources/my/uri_files/components?expanded=false")); assertThat(request, wasMethod("GET")); } |
### Question:
SpringAuthServiceFactory { public SpringAuthService create() { AuthRestApi restApi = new AuthRestApi(mClient); JSEncryptionAlgorithm encryptionAlgorithm = JSEncryptionAlgorithm.create(); return new SpringAuthService(restApi, encryptionAlgorithm); } SpringAuthServiceFactory(NetworkClient client); SpringAuthService create(); }### Answer:
@Test public void testCreate() throws Exception { SpringAuthService service = authServiceFactory.create(); assertThat(service, is(notNullValue())); } |
### Question:
Utils { public static String normalizeBaseUrl(String url) { if (url == null || url.length() == 0) { return url; } if (url.endsWith("/")) { return url; } return url + "/"; } private Utils(); static T checkNotNull(T object, String message); static void checkArgument(boolean condition, String message); static int headerToInt(com.squareup.okhttp.Headers headers, String key); static String normalizeBaseUrl(String url); static String joinString(CharSequence delimiter, Iterable tokens); }### Answer:
@Test public void normalizeBaseUrlShouldAddTrailingSlashIfMissing() { String url = "http: assertThat(Utils.normalizeBaseUrl(url), is(url + "/")); }
@Test public void normalizeBaseUrlShouldNotNormalizeEmptyString() { String url = ""; assertThat(Utils.normalizeBaseUrl(url), is("")); }
@Test public void normalizeBaseUrlShouldNotNormalizeNullString() { String url = null; assertThat(Utils.normalizeBaseUrl(url), is(nullValue())); } |
### Question:
JobData { @Override public final boolean equals(Object o) { if (this == o) return true; if (!(o instanceof JobData)) return false; JobData jobData = (JobData) o; if (mId != jobData.mId) return false; if (mVersion != jobData.mVersion) return false; if (!mCreationDate.equals(jobData.mCreationDate)) return false; if (!mDescription.equals(jobData.mDescription)) return false; if (!mLabel.equals(jobData.mLabel)) return false; if (!mOutputFormats.equals(jobData.mOutputFormats)) return false; if (!mUsername.equals(jobData.mUsername)) return false; return true; } JobData(int id,
int version,
@NotNull String username,
@NotNull String label,
@NotNull String description,
@NotNull Date creationDate,
@NotNull List<JobOutputFormat> outputFormats); @NotNull int getId(); int getVersion(); @NotNull String getUsername(); @NotNull String getLabel(); @NotNull String getDescription(); @NotNull Date getCreationDate(); @NotNull List<JobOutputFormat> getOutputFormats(); @Override final boolean equals(Object o); @Override final int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { EqualsVerifier.forClass(JobData.class).verify(); } |
### Question:
TimePattern { public void setRange(int start, int end) { if (start < mLowerBound) { throw new IllegalArgumentException("start cannot be less than lower bound."); } if (end > mHigherBound) { throw new IllegalArgumentException("end cannot be more than upper bound."); } if (start > end) { throw new IllegalArgumentException("start must be lesser than end."); } mPattern.setLength(0); mPattern.append(String.valueOf(start)) .append("-") .append(String.valueOf(end)); } TimePattern(int lowerBound, int higherBound); void setRange(int start, int end); @Override String toString(); void setValue(int value); void setIncrement(int interval, int from); void setRawValue(String rawValue); String parse(String rawValue); }### Answer:
@Test public void should_throw_if_lower_bound_higher_than_upper_one() throws Exception { expected.expect(IllegalArgumentException.class); expected.expectMessage("start must be lesser than end."); mTimePattern.setRange(10, 0); }
@Test public void should_throw_if_start_less_than_lower_bound() throws Exception { expected.expect(IllegalArgumentException.class); expected.expectMessage("start cannot be less than lower bound."); mTimePattern.setRange(-10, 0); }
@Test public void should_throw_if_upper_bound_negative() throws Exception { expected.expect(IllegalArgumentException.class); expected.expectMessage("end cannot be more than upper bound."); mTimePattern.setRange(0, 200); } |
### Question:
TimePattern { public void setValue(int value) { validateWithinBounds(value, String.format("Value should be within bounds [ %d, %d ]", mLowerBound, mHigherBound)); mPattern.setLength(0); mPattern.append(String.valueOf(value)); } TimePattern(int lowerBound, int higherBound); void setRange(int start, int end); @Override String toString(); void setValue(int value); void setIncrement(int interval, int from); void setRawValue(String rawValue); String parse(String rawValue); }### Answer:
@Test public void should_not_accept_value_that_less_than_lower_bound() throws Exception { expected.expect(IllegalArgumentException.class); expected.expectMessage("Value should be within bounds [ 0, 59 ]"); mTimePattern.setValue(-10); }
@Test public void should_not_accept_value_that_more_than_upper_bound() throws Exception { expected.expect(IllegalArgumentException.class); expected.expectMessage("Value should be within bounds [ 0, 59 ]"); mTimePattern.setValue(100); } |
### Question:
TimePattern { public void setIncrement(int interval, int from) { validateWithinBounds(interval, String.format("Interval should be within bounds [ %d, %d ]", mLowerBound, mHigherBound)); validateWithinBounds(from, String.format("From should be within bounds [ %d, %d ]", mLowerBound, mHigherBound)); mPattern.setLength(0); mPattern.append(String.valueOf(interval)) .append("/") .append(String.valueOf(from)); } TimePattern(int lowerBound, int higherBound); void setRange(int start, int end); @Override String toString(); void setValue(int value); void setIncrement(int interval, int from); void setRawValue(String rawValue); String parse(String rawValue); }### Answer:
@Test public void should_not_accept_interval_that_less_than_lower_bound() throws Exception { expected.expect(IllegalArgumentException.class); expected.expectMessage("Interval should be within bounds [ 0, 59 ]"); mTimePattern.setIncrement(-10, 5); }
@Test public void should_not_accept_interval_that_more_than_upper_bound() throws Exception { expected.expect(IllegalArgumentException.class); expected.expectMessage("Interval should be within bounds [ 0, 59 ]"); mTimePattern.setIncrement(100, -5); }
@Test public void should_not_accept_from_that_less_than_lower_bound() throws Exception { expected.expect(IllegalArgumentException.class); expected.expectMessage("From should be within bounds [ 0, 59 ]"); mTimePattern.setIncrement(0, -5); }
@Test public void should_not_accept_from_that_more_than_upper_bound() throws Exception { expected.expect(IllegalArgumentException.class); expected.expectMessage("From should be within bounds [ 0, 59 ]"); mTimePattern.setIncrement(0, 100); } |
### Question:
RepositoryDestination { @Nullable public Boolean getUseDefaultReportOutputFolderURI() { return useDefaultReportOutputFolderURI; } RepositoryDestination(Builder builder); @Nullable Boolean getSequentialFileNames(); @Nullable Boolean getOverwriteFiles(); @Nullable Boolean getSaveToRepository(); @Nullable Boolean getUseDefaultReportOutputFolderURI(); @Nullable String getTimestampPattern(); @Nullable String getOutputDescription(); @Nullable String getOutputLocalFolder(); @NotNull String getFolderUri(); @Nullable String getDefaultReportOutputFolderURI(); @Nullable JobOutputFtpInfo getOutputFtpInfo(); Builder newBuilder(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void should_use_default_folder_uri_if_one_not_supplied() throws Exception { RepositoryDestination destination = new RepositoryDestination.Builder().build(); assertThat(destination.getUseDefaultReportOutputFolderURI(), is(true)); } |
### Question:
ReportMetadata { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ReportMetadata that = (ReportMetadata) o; if (totalPages != that.totalPages) return false; if (uri != null ? !uri.equals(that.uri) : that.uri != null) return false; return true; } ReportMetadata(String uri, int totalPages); String getUri(); int getTotalPages(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void testEquals() throws Exception { EqualsVerifier.forClass(ReportMetadata.class).verify(); } |
### Question:
ReportOption { @Override public final boolean equals(Object o) { if (this == o) return true; if (!(o instanceof ReportOption)) return false; ReportOption that = (ReportOption) o; if (!id.equals(that.id)) return false; if (!label.equals(that.label)) return false; if (!uri.equals(that.uri)) return false; return true; } private ReportOption(@NotNull String id, @NotNull String uri, @NotNull String label); @NotNull String getId(); @NotNull String getUri(); @NotNull String getLabel(); @Override final boolean equals(Object o); @Override final int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { EqualsVerifier.forClass(ReportOption.class).verify(); } |
### Question:
PageRange { @NotNull public static PageRange parse(@NotNull String pages) { Preconditions.checkNotNull(pages, "Pages should not be null"); int lowerBound = parseLowerBound(pages); int upperBound = parseUpperBound(pages); return new PageRange(lowerBound, upperBound); } private PageRange(int lowerBound, int upperBound); int getLowerBound(); int getUpperBound(); boolean isRange(); @NotNull static PageRange parse(@NotNull String pages); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void throwsNumberFormatExceptionIfLowerBoundNotANumber() { mExpectedException.expect(NumberFormatException.class); PageRange.parse("q"); }
@Test public void throwsNumberFormatExceptionIfUpperBoundNotANumber() { mExpectedException.expect(NumberFormatException.class); PageRange.parse("1-q"); }
@Test public void should_not_allow_null() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Pages should not be null"); PageRange.parse(null); } |
### Question:
PageRange { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; PageRange pageRange = (PageRange) o; if (mLowerBound != pageRange.mLowerBound) return false; if (mUpperBound != pageRange.mUpperBound) return false; return true; } private PageRange(int lowerBound, int upperBound); int getLowerBound(); int getUpperBound(); boolean isRange(); @NotNull static PageRange parse(@NotNull String pages); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { EqualsVerifier.forClass(PageRange.class).verify(); } |
### Question:
RepositoryUseCase { public DashboardComponentCollection requestDashboardComponents(String dashboardUri) throws ServiceException { try { return mRestApi.requestDashboardComponents(dashboardUri); } catch (HttpException e) { throw mExceptionMapper.transform(e); } catch (IOException e) { throw mExceptionMapper.transform(e); } } RepositoryUseCase(ServiceExceptionMapper exceptionMapper, RepositoryRestApi restApi); DashboardComponentCollection requestDashboardComponents(String dashboardUri); }### Answer:
@Test public void list_dashboard_components() throws Exception { useCase.requestDashboardComponents(DASHBOARD_URI); verify(mRepositoryRestApi).requestDashboardComponents(DASHBOARD_URI); }
@Test public void list_dashboard_components_adapts_io_exception() throws Exception { when(mRepositoryRestApi.requestDashboardComponents(anyString())).thenThrow(mIOException); try { useCase.requestDashboardComponents(DASHBOARD_URI); fail("Should adapt IO exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mIOException); } }
@Test public void list_dashboard_components_adapts_http_exception() throws Exception { when(mRepositoryRestApi.requestDashboardComponents(anyString())).thenThrow(mHttpException); try { useCase.requestDashboardComponents(DASHBOARD_URI); fail("Should adapt HTTP exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mHttpException); } } |
### Question:
ReportOptionMapper { public Set<ReportOption> transform(Set<ReportOptionEntity> entities) { Set<ReportOption> options = new HashSet<>(entities.size()); for (ReportOptionEntity entity : entities) { if (entity != null) { ReportOption option = transform(entity); options.add(option); } } return options; } Set<ReportOption> transform(Set<ReportOptionEntity> entities); ReportOption transform(ReportOptionEntity entity); }### Answer:
@Test public void should_map_entities_to_data_objects() throws Exception { Set<ReportOption> expected = mReportOptionMapper.transform(Collections.singleton(mEntity)); assertThat(expected, is(not(empty()))); }
@Test public void should_map_entity_to_data_object() throws Exception { ReportOption expected = mReportOptionMapper.transform(mEntity); assertThat(expected.getId(), is("id")); assertThat(expected.getUri(), is("/my/uri")); assertThat(expected.getLabel(), is("label")); } |
### Question:
ReportOptionsUseCase { public Set<ReportOption> requestReportOptionsList(String reportUnitUri) throws ServiceException { try { Set<ReportOptionEntity> entities = mReportOptionRestApi.requestReportOptionsList(reportUnitUri); return mReportOptionMapper.transform(entities); } catch (HttpException e) { throw mExceptionMapper.transform(e); } catch (IOException e) { throw mExceptionMapper.transform(e); } } ReportOptionsUseCase(ServiceExceptionMapper exceptionMapper, ReportOptionRestApi reportOptionRestApi, ReportOptionMapper reportOptionMapper); Set<ReportOption> requestReportOptionsList(String reportUnitUri); ReportOption createReportOption(String reportUri,
String optionLabel,
List<ReportParameter> parameters,
boolean overwrite); void updateReportOption(String reportUri, String optionId, List<ReportParameter> parameters); void deleteReportOption(String reportUri, String optionId); }### Answer:
@Test public void should_list_report_options() throws Exception { reportOptionsUseCase.requestReportOptionsList(REPORT_URI); verify(mReportOptionMapper).transform(anySetOf(ReportOptionEntity.class)); verify(mReportOptionRestApi).requestReportOptionsList(REPORT_URI); }
@Test public void list_report_options_adapts_io_exception() throws Exception { when(mReportOptionRestApi.requestReportOptionsList(anyString())).thenThrow(mIOException); try { reportOptionsUseCase.requestReportOptionsList(REPORT_URI); fail("Should adapt IO exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mIOException); } }
@Test public void list_report_options_adapts_http_exception() throws Exception { when(mReportOptionRestApi.requestReportOptionsList(anyString())).thenThrow(mHttpException); try { reportOptionsUseCase.requestReportOptionsList(REPORT_URI); fail("Should adapt HTTP exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mHttpException); } } |
### Question:
ReportOptionsUseCase { public void updateReportOption(String reportUri, String optionId, List<ReportParameter> parameters) throws ServiceException { try { mReportOptionRestApi.updateReportOption(reportUri, optionId, parameters); } catch (HttpException e) { throw mExceptionMapper.transform(e); } catch (IOException e) { throw mExceptionMapper.transform(e); } } ReportOptionsUseCase(ServiceExceptionMapper exceptionMapper, ReportOptionRestApi reportOptionRestApi, ReportOptionMapper reportOptionMapper); Set<ReportOption> requestReportOptionsList(String reportUnitUri); ReportOption createReportOption(String reportUri,
String optionLabel,
List<ReportParameter> parameters,
boolean overwrite); void updateReportOption(String reportUri, String optionId, List<ReportParameter> parameters); void deleteReportOption(String reportUri, String optionId); }### Answer:
@Test public void should_update_report_option() throws Exception { reportOptionsUseCase.updateReportOption(REPORT_URI, OPTION_ID, REPORT_PARAMETERS); verify(mReportOptionRestApi).updateReportOption(REPORT_URI, OPTION_ID, REPORT_PARAMETERS); }
@Test public void update_report_option_adapts_io_exception() throws Exception { doThrow(mIOException).when(mReportOptionRestApi).updateReportOption(anyString(), anyString(), anyListOf(ReportParameter.class)); try { reportOptionsUseCase.updateReportOption(REPORT_URI, OPTION_LABEL, REPORT_PARAMETERS); fail("Should adapt IO exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mIOException); } }
@Test public void update_report_option_adapts_http_exception() throws Exception { doThrow(mHttpException).when(mReportOptionRestApi).updateReportOption(anyString(), anyString(), anyListOf(ReportParameter.class)); try { reportOptionsUseCase.updateReportOption(REPORT_URI, OPTION_LABEL, REPORT_PARAMETERS); fail("Should adapt HTTP exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mHttpException); } } |
### Question:
ReportOptionsUseCase { public void deleteReportOption(String reportUri, String optionId) throws ServiceException { try { mReportOptionRestApi.deleteReportOption(reportUri, optionId); } catch (HttpException e) { throw mExceptionMapper.transform(e); } catch (IOException e) { throw mExceptionMapper.transform(e); } } ReportOptionsUseCase(ServiceExceptionMapper exceptionMapper, ReportOptionRestApi reportOptionRestApi, ReportOptionMapper reportOptionMapper); Set<ReportOption> requestReportOptionsList(String reportUnitUri); ReportOption createReportOption(String reportUri,
String optionLabel,
List<ReportParameter> parameters,
boolean overwrite); void updateReportOption(String reportUri, String optionId, List<ReportParameter> parameters); void deleteReportOption(String reportUri, String optionId); }### Answer:
@Test public void should_delete_report_option() throws Exception { reportOptionsUseCase.deleteReportOption(REPORT_URI, OPTION_LABEL); verify(mReportOptionRestApi).deleteReportOption(REPORT_URI, OPTION_ID); }
@Test public void delete_report_option_adapts_io_exception() throws Exception { doThrow(mIOException).when(mReportOptionRestApi).deleteReportOption(anyString(), anyString()); try { reportOptionsUseCase.deleteReportOption(REPORT_URI, OPTION_LABEL); fail("Should adapt IO exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mIOException); } }
@Test public void delete_report_option_adapts_http_exception() throws Exception { doThrow(mHttpException).when(mReportOptionRestApi).deleteReportOption(anyString(), anyString()); try { reportOptionsUseCase.deleteReportOption(REPORT_URI, OPTION_LABEL); fail("Should adapt HTTP exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mHttpException); } } |
### Question:
ReportControlsUseCase { public List<InputControl> requestControls(String reportUri, Set<String> ids, boolean excludeState) throws ServiceException { try { return mRestApi.requestInputControls(reportUri, ids, excludeState); } catch (HttpException e) { throw mExceptionMapper.transform(e); } catch (IOException e) { throw mExceptionMapper.transform(e); } } ReportControlsUseCase(ServiceExceptionMapper exceptionMapper, InputControlRestApi restApi); List<InputControl> requestControls(String reportUri, Set<String> ids, boolean excludeState); List<InputControlState> requestControlsValues(String reportUri,
List<ReportParameter> parameters,
boolean fresh); List<InputControlState> requestResourceValues(String resourceUri, boolean freshData); }### Answer:
@Test public void should_request_controls() throws Exception { mReportControlsUseCase.requestControls(REPORT_URI, null, false); verify(mRestApi).requestInputControls(REPORT_URI, null, false); }
@Test public void request_controls_adapt_io_exception() throws Exception { when(mRestApi.requestInputControls(anyString(), anySetOf(String.class), anyBoolean())).thenThrow(mIOException); try { mReportControlsUseCase.requestControls(REPORT_URI, null, false); fail("Should adapt IO exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mIOException); } }
@Test public void request_controls_adapt_http_exception() throws Exception { when(mRestApi.requestInputControls(anyString(), anySetOf(String.class), anyBoolean())).thenThrow(mHttpException); try { mReportControlsUseCase.requestControls(REPORT_URI, null, false); fail("Should adapt HTTP exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mHttpException); } } |
### Question:
ReportControlsUseCase { public List<InputControlState> requestResourceValues(String resourceUri, boolean freshData) throws ServiceException { try { return mRestApi.requestInputControlsInitialStates(resourceUri, freshData); } catch (HttpException e) { throw mExceptionMapper.transform(e); } catch (IOException e) { throw mExceptionMapper.transform(e); } } ReportControlsUseCase(ServiceExceptionMapper exceptionMapper, InputControlRestApi restApi); List<InputControl> requestControls(String reportUri, Set<String> ids, boolean excludeState); List<InputControlState> requestControlsValues(String reportUri,
List<ReportParameter> parameters,
boolean fresh); List<InputControlState> requestResourceValues(String resourceUri, boolean freshData); }### Answer:
@Test public void should_request_resource_values() throws Exception { mReportControlsUseCase.requestResourceValues(REPORT_URI, false); verify(mRestApi).requestInputControlsInitialStates(REPORT_URI, false); } |
### Question:
ReportControlsUseCase { public List<InputControlState> requestControlsValues(String reportUri, List<ReportParameter> parameters, boolean fresh) throws ServiceException { try { return mRestApi.requestInputControlsStates(reportUri, parameters, fresh); } catch (HttpException e) { throw mExceptionMapper.transform(e); } catch (IOException e) { throw mExceptionMapper.transform(e); } } ReportControlsUseCase(ServiceExceptionMapper exceptionMapper, InputControlRestApi restApi); List<InputControl> requestControls(String reportUri, Set<String> ids, boolean excludeState); List<InputControlState> requestControlsValues(String reportUri,
List<ReportParameter> parameters,
boolean fresh); List<InputControlState> requestResourceValues(String resourceUri, boolean freshData); }### Answer:
@Test public void request_controls_values_adapt_io_exception() throws Exception { when(mRestApi.requestInputControlsStates(anyString(), anyListOf(ReportParameter.class), anyBoolean())).thenThrow(mIOException); try { mReportControlsUseCase.requestControlsValues(REPORT_URI, PARAMS, false); fail("Should adapt IO exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mIOException); } }
@Test public void request_controls_values_adapt_http_exception() throws Exception { when(mRestApi.requestInputControlsStates(anyString(), anyListOf(ReportParameter.class), anyBoolean())).thenThrow(mHttpException); try { mReportControlsUseCase.requestControlsValues(REPORT_URI, PARAMS, false); fail("Should adapt HTTP exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mHttpException); } }
@Test public void should_request_controls_values() throws Exception { mReportControlsUseCase.requestControlsValues(REPORT_URI, PARAMS, false); verify(mRestApi).requestInputControlsStates(REPORT_URI, PARAMS, false); } |
### Question:
ServerInfoTransformer { public ServerInfo transform(ServerInfoData response) { ServerInfo serverInfo = new ServerInfo(); serverInfo.setBuild(response.getBuild()); SimpleDateFormat dateDateFormat = new SimpleDateFormat(response.getDateFormatPattern()); serverInfo.setDateFormatPattern(dateDateFormat); SimpleDateFormat dateTimeFormat = new SimpleDateFormat(response.getDatetimeFormatPattern()); serverInfo.setDatetimeFormatPattern(dateTimeFormat); ServerVersion version = ServerVersion.valueOf(response.getVersion()); serverInfo.setVersion(version); serverInfo.setEdition(response.getEdition()); serverInfo.setEditionName(response.getEditionName()); Set<String> features = parseFeatureSet(response.getFeatures()); serverInfo.setFeatures(features); serverInfo.setLicenseType(response.getLicenseType()); return serverInfo; } private ServerInfoTransformer(); static ServerInfoTransformer get(); ServerInfo transform(ServerInfoData response); }### Answer:
@Test public void shouldTransform() { ServerInfo info = transformerUnderTest.transform(mServerInfoData); assertThat(info.getBuild(), is("20150527_1447")); assertThat(info.getDateFormatPattern(), is(new SimpleDateFormat("yyyy-MM-dd"))); assertThat(info.getDatetimeFormatPattern(), is(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"))); assertThat(info.getVersion(), is(ServerVersion.v6_1)); assertThat(info.isEditionPro(), is(true)); assertThat(info.getEditionName(), is("Enterprise for AWS")); assertThat(info.getFeatures(), contains("Fusion")); assertThat(info.getLicenseType(), is("Type")); } |
### Question:
FileResourceMapper extends AbstractResourceMapper<FileResource, FileLookup> { @Override public FileResource transform(FileLookup lookup) { FileResource.Builder builder = new FileResource.Builder(); AbstractResourceBuilder abstractResourceBuilder = builder.addResource(); buildLookup(abstractResourceBuilder, lookup); FileResource.Type type = FileResource.Type.valueOf(lookup.getType()); builder.withFileType(type); return builder.build(); } FileResourceMapper(@NotNull SimpleDateFormat format, @Nullable ResourceType backupType); FileResourceMapper(@NotNull SimpleDateFormat format); @Override FileResource transform(FileLookup lookup); }### Answer:
@Test public void should_map_file_lookup() throws Exception { mockFileLookup(); FileResource resource = mapper.transform(mFileLookup); assertThat(resource.getType(), is(FileResource.Type.pdf)); } |
### Question:
RepositorySearchCriteria { @NotNull public static Builder builder() { return new Builder(); } private RepositorySearchCriteria(Builder builder); @NotNull static Builder builder(); @NotNull static RepositorySearchCriteria empty(); int getLimit(); int getOffset(); @Nullable String getQuery(); @Nullable Boolean getRecursive(); @Nullable SortType getSortBy(); int getResourceMask(); @Nullable String getFolderUri(); AccessType getAccessType(); static final int DEFAULT_OFFSET; static final int DEFAULT_LIMIT; static int ALL; static int REPORT; static int DASHBOARD; static int LEGACY_DASHBOARD; static int FOLDER; static int REPORT_OPTION; static int FILE; }### Answer:
@Test public void shouldNotAcceptNegativeOffset() { mExpectedException.expect(IllegalArgumentException.class); mExpectedException.expectMessage("Offset should be positive"); RepositorySearchCriteria.builder().withOffset(-1).build(); }
@Test public void shouldNotAcceptNegativeLimit() { mExpectedException.expect(IllegalArgumentException.class); mExpectedException.expectMessage("Limit should be positive"); RepositorySearchCriteria.builder().withLimit(-1).build(); } |
### Question:
ReportResourceMapper extends AbstractResourceMapper<ReportResource, ReportLookup> { @Override public ReportResource transform(ReportLookup lookup) { ReportResource.Builder builder = new ReportResource.Builder(); AbstractResourceBuilder abstractResourceBuilder = builder.addResource(); buildLookup(abstractResourceBuilder, lookup); builder.withAlwaysPrompt(lookup.alwaysPromptControls()); return builder.build(); } ReportResourceMapper(@NotNull SimpleDateFormat format, @Nullable ResourceType backupType); ReportResourceMapper(@NotNull SimpleDateFormat format); @Override ReportResource transform(ReportLookup lookup); }### Answer:
@Test public void should_map_file_lookup() throws Exception { mockFileLookup(); ReportResource resource = mapper.transform(mReportLookup); assertThat(resource.alwaysPromptControls(), is(true)); } |
### Question:
ResourceMapper extends AbstractResourceMapper<Resource, ResourceLookup> { @Override public Resource transform(ResourceLookup lookup) { AbstractResourceBuilder<?> builder = new AbstractResourceBuilder<>(null); buildLookup(builder, lookup); return builder.getResourceBuilder().build(); } ResourceMapper(@NotNull SimpleDateFormat format); ResourceMapper(@NotNull SimpleDateFormat format, @Nullable ResourceType backupType); @Override Resource transform(ResourceLookup lookup); }### Answer:
@Test public void should_map_lookup_to_resource() throws Exception { long creationTime = TestConstants.DATE_TIME_FORMAT.parse("2013-10-03 16:32:05").getTime(); long updateTime = TestConstants.DATE_TIME_FORMAT.parse("2013-11-03 16:32:05").getTime(); Resource resource = mMapper.transform(mResourceLookup); assertThat(resource.getCreationDate().getTime(), is(creationTime)); assertThat(resource.getUpdateDate().getTime(), is(updateTime)); assertThat(resource.getDescription(), is("description")); assertThat(resource.getLabel(), is("label")); assertThat(resource.getUri(), is("/my/uri")); assertThat(resource.getResourceType(), is(ResourceType.reportUnit)); assertThat(resource.getVersion(), is(100)); assertThat(resource.getPermissionMask(), is(PermissionMask.NO_ACCESS)); } |
### Question:
RepositorySearchTaskV5_5 extends RepositorySearchTask { @NotNull @Override public List<Resource> nextLookup() throws ServiceException { int limit = mInitialCriteria.getLimit(); int offset = mInitialCriteria.getOffset(); if (mEndReached || limit == 0) { return EMPTY_RESPONSE; } calculateDisposition(offset); return Collections.unmodifiableList(internalSearch(limit)); } RepositorySearchTaskV5_5(InternalCriteria criteria, SearchUseCase searchUseCase); @NotNull @Override List<Resource> nextLookup(); @Override boolean hasNext(); }### Answer:
@Test public void shouldReturnEmptyCollectionForZeroLimit() throws Exception { InternalCriteria userCriteria = new InternalCriteria.Builder().limit(0).offset(5).create(); RepositorySearchTask strategy = new RepositorySearchTaskV5_5(userCriteria, mSearchUseCase); List<Resource> result = strategy.nextLookup(); assertThat(result, is(empty())); verifyZeroInteractions(mSearchUseCase); } |
### Question:
SearchUseCase { @NotNull public SearchResult performSearch(@NotNull final InternalCriteria internalCriteria) throws ServiceException { final SimpleDateFormat dateTimeFormat = mInfoCacheManager.getInfo().getDatetimeFormatPattern(); Call<SearchResult> call = new Call<SearchResult>() { @Override public SearchResult perform() throws IOException, HttpException { Map<String, Object> criteria = CriteriaMapper.map(internalCriteria); ResourceSearchResult response = mRestApi.searchResources(criteria); List<Resource> resources = mDataMapper.toResources(response.getResources(), dateTimeFormat); return new SearchResult(resources, response.getNextOffset()); } }; return mCallExecutor.execute(call); } SearchUseCase(ResourcesMapper dataMapper,
RepositoryRestApi restApi,
InfoCacheManager infoCacheManager,
CallExecutor callExecutor); @NotNull SearchResult performSearch(@NotNull final InternalCriteria internalCriteria); }### Answer:
@Test public void shouldProvideAndAdaptSearchResult() throws Exception { when(mResult.getNextOffset()).thenReturn(100); when(mRepositoryRestApi.searchResources(anyMapOf(String.class, Object.class))).thenReturn(mResult); List<Resource> resources = new ArrayList<Resource>(); when(mDataMapper.toResources(anyCollectionOf(ResourceLookup.class), Matchers.any(SimpleDateFormat.class))).thenReturn(resources); SearchResult result = objectUnderTest.performSearch(mCriteria); assertThat(result, is(not(nullValue()))); assertThat(result.getNextOffset(), is(100)); assertThat(result.getResources(), is(resources)); verify(mRepositoryRestApi).searchResources(anyMapOf(String.class, Object.class)); } |
### Question:
RepositorySearchTaskProxy extends RepositorySearchTask { @NotNull @Override public List<Resource> nextLookup() throws ServiceException { if (mDelegate == null) { mDelegate = mSearchTaskFactory.create(); } return mDelegate.nextLookup(); } RepositorySearchTaskProxy(SearchTaskFactory searchTaskFactory); @NotNull @Override List<Resource> nextLookup(); @Override boolean hasNext(); }### Answer:
@Test public void testNextLookup() throws Exception { searchTask.nextLookup(); verify(mSearchTaskFactory).create(); searchTask.nextLookup(); verifyNoMoreInteractions(mSearchTaskFactory); } |
### Question:
RepositorySearchTaskProxy extends RepositorySearchTask { @Override public boolean hasNext() { return mDelegate != null && mDelegate.hasNext(); } RepositorySearchTaskProxy(SearchTaskFactory searchTaskFactory); @NotNull @Override List<Resource> nextLookup(); @Override boolean hasNext(); }### Answer:
@Test public void testHasNext() throws Exception { when(mDelegate.hasNext()).thenReturn(true); assertThat("Has next returns false by default", searchTask.hasNext(), is(false)); searchTask.nextLookup(); assertThat("Has next returns true from delegate", searchTask.hasNext(), is(true)); } |
### Question:
JobTriggerMapper extends JobMapper { @Override public void mapEntityOnForm(JobForm.Builder form, JobFormEntity entity) { JobSimpleTriggerEntity simpleTrigger = entity.getSimpleTrigger(); if (simpleTrigger == null) { mCalendarTriggerMapper.mapEntityOnForm(form, entity); } else { Integer recurrenceInterval = simpleTrigger.getRecurrenceInterval(); String recurrenceIntervalUnit = simpleTrigger.getRecurrenceIntervalUnit(); boolean triggerIsSimpleType = (recurrenceInterval != null && recurrenceIntervalUnit != null); if (triggerIsSimpleType) { mSimpleTriggerMapper.mapEntityOnForm(form, entity); } else { mNoneTriggerMapper.mapEntityOnForm(form, entity); } } } JobTriggerMapper(
JobCalendarTriggerMapper calendarTriggerMapper,
JobSimpleTriggerMapper simpleTriggerMapper,
JobNoneTriggerMapper noneTriggerMapper
); @Override void mapFormOnEntity(JobForm form, JobFormEntity entity); @Override void mapEntityOnForm(JobForm.Builder form, JobFormEntity entity); }### Answer:
@Test public void should_map_simple_entity_trigger_to_form() throws Exception { givenEntityFormWithSimpleTrigger(); whenMapsEntityToForm(); verify(mSimpleTriggerMapper).mapEntityOnForm(formBuilder, providedFormEntity); }
@Test public void should_map_calendar_entity_trigger_to_form() throws Exception { givenEntityFormWithCalendarTrigger(); whenMapsEntityToForm(); verify(mCalendarTriggerMapper).mapEntityOnForm(formBuilder, providedFormEntity); }
@Test public void should_map_none_entity_trigger_to_form() throws Exception { givenEntityFormWithNoneTrigger(); whenMapsEntityToForm(); verify(mNoneTriggerMapper).mapEntityOnForm(formBuilder, providedFormEntity); } |
### Question:
JobTriggerMapper extends JobMapper { @Override public void mapFormOnEntity(JobForm form, JobFormEntity entity) { Trigger trigger = form.getTrigger(); if (trigger == null) { mNoneTriggerMapper.mapFormOnEntity(form, entity); } else { Recurrence recurrence = trigger.getRecurrence(); if (recurrence instanceof CalendarRecurrence) { mCalendarTriggerMapper.mapFormOnEntity(form, entity); } else { mSimpleTriggerMapper.mapFormOnEntity(form, entity); } } } JobTriggerMapper(
JobCalendarTriggerMapper calendarTriggerMapper,
JobSimpleTriggerMapper simpleTriggerMapper,
JobNoneTriggerMapper noneTriggerMapper
); @Override void mapFormOnEntity(JobForm form, JobFormEntity entity); @Override void mapEntityOnForm(JobForm.Builder form, JobFormEntity entity); }### Answer:
@Test public void should_map_simple_trigger_to_entity() throws Exception { givenFormWithSimpleTrigger(); whenMapsFormToEntity(); verify(mSimpleTriggerMapper).mapFormOnEntity(providedForm, mappedFormEntity); }
@Test public void should_map_calendar_trigger_to_entity() throws Exception { givenFormWithCalendarTrigger(); whenMapsFormToEntity(); verify(mCalendarTriggerMapper).mapFormOnEntity(providedForm, mappedFormEntity); }
@Test public void should_map_none_trigger_to_entity() throws Exception { givenFormWithNoneTrigger(); whenMapsFormToEntity(); verify(mNoneTriggerMapper).mapFormOnEntity(providedForm, mappedFormEntity); } |
### Question:
PathResolver { public HttpUrl resolve(HttpUrl base) { HttpUrl.Builder builder = base.newBuilder(); for (String path : mPaths) { builder.addPathSegment(path); } return builder.build(); } PathResolver(List<String> paths); HttpUrl resolve(HttpUrl base); }### Answer:
@Test public void shouldAggregateSinglePath() throws Exception { HttpUrl base = HttpUrl.parse("http: PathResolver resolver = new PathResolver.Builder() .addPath("path") .build(); HttpUrl expected = resolver.resolve(base); assertThat(expected, is(HttpUrl.parse("http: }
@Test public void shouldAggregateMultiplePaths() throws Exception { HttpUrl base = HttpUrl.parse("http: PathResolver resolver = new PathResolver.Builder() .addPaths("/path/a/b") .build(); HttpUrl expected = resolver.resolve(base); assertThat(expected, is(HttpUrl.parse("http: }
@Test public void shouldAggregateSinglePathAsItIs() throws Exception { HttpUrl base = HttpUrl.parse("http: PathResolver resolver = new PathResolver.Builder() .addPaths("path") .build(); HttpUrl expected = resolver.resolve(base); assertThat(expected, is(HttpUrl.parse("http: }
@Test public void shouldNotAggregatePathIfEmptinessSupplied() throws Exception { HttpUrl base = HttpUrl.parse("http: PathResolver resolver = new PathResolver.Builder() .addPath("") .build(); HttpUrl expected = resolver.resolve(base); assertThat(expected, is(HttpUrl.parse("http: PathResolver resolver2 = new PathResolver.Builder() .addPaths("") .build(); HttpUrl expected2 = resolver2.resolve(base); assertThat(expected2, is(HttpUrl.parse("http: } |
### Question:
JobSourceMapper extends JobMapper { @Override public void mapFormOnEntity(JobForm form, JobFormEntity entity) { JobSource source = form.getSource(); List<ReportParameter> params = source.getParameters(); Map<String, Set<String>> values = mapSourceParamValues(params); entity.setSourceUri(source.getUri()); entity.setSourceParameters(values); } @Override void mapFormOnEntity(JobForm form, JobFormEntity entity); @Override void mapEntityOnForm(JobForm.Builder form, JobFormEntity entity); }### Answer:
@Test public void should_map_form_to_entity() throws Exception { List<ReportParameter> parameters = Collections.singletonList( new ReportParameter("key", Collections.singleton("value"))); JobSource source = new JobSource.Builder() .withUri("/my/uri") .withParameters(parameters) .build(); JobFormEntity mappedEntity = formFactory.givenNewJobFormEntity(); JobForm preparedForm = formFactory.givenJobFormBuilderWithValues() .withJobSource(source) .build(); mapperUnderTest.mapFormOnEntity(preparedForm, mappedEntity); assertThat(mappedEntity.getSourceUri(), is("/my/uri")); Map<String, Set<String>> params = mappedEntity.getSourceParameters(); Collection<String> values = new ArrayList<>(); for (Map.Entry<String, Set<String>> entry : params.entrySet()) { values.addAll(entry.getValue()); } assertThat(params.keySet(), hasItem("key")); assertThat(values, hasItem("value")); } |
### Question:
JobSourceMapper extends JobMapper { @Override public void mapEntityOnForm(JobForm.Builder form, JobFormEntity entity) { JobSource.Builder builder = new JobSource.Builder(); builder.withUri(entity.getSourceUri()); Map<String, Set<String>> parameters = entity.getSourceParameters(); if (parameters != null) { List<ReportParameter> params = mapParams(parameters); builder.withParameters(params); } JobSource source = builder.build(); form.withJobSource(source); } @Override void mapFormOnEntity(JobForm form, JobFormEntity entity); @Override void mapEntityOnForm(JobForm.Builder form, JobFormEntity entity); }### Answer:
@Test public void should_map_entity_to_form() throws Exception { JobFormEntity preparedEntity = formFactory.givenJobFormEntityWithValues(); JobForm.Builder form = formFactory.givenJobFormBuilderWithValues(); mapperUnderTest.mapEntityOnForm(form, preparedEntity); JobSource source = form.build().getSource(); assertThat(source.getUri(), is("/my/uri")); assertThat(source.getParameters(), hasItem(new ReportParameter("key", Collections.singleton("value")))); } |
### Question:
ReportScheduleUseCase { public JobData createJob(JobForm form) throws ServiceException { return alterJob(form, null); } ReportScheduleUseCase(ServiceExceptionMapper exceptionMapper,
ReportScheduleRestApi scheduleRestApi,
InfoCacheManager cacheManager,
JobSearchCriteriaMapper searchCriteriaMapper,
JobDataMapper jobDataMapper,
JobFormMapper jobFormMapper,
JobUnitMapper jobUnitMapper
); List<JobUnit> searchJob(JobSearchCriteria criteria); JobData createJob(JobForm form); JobData updateJob(int id, JobForm form); Set<Integer> deleteJobs(Set<Integer> jobIds); JobForm readJob(int jobId); }### Answer:
@Test public void should_perform_create_job() throws Exception { when(mScheduleRestApi.createJob(any(JobFormEntity.class))).thenReturn(mJobDescriptor); useCase.createJob(mJobForm); verify(mJobDataMapper).transform(mJobDescriptor, SIMPLE_DATE_FORMAT); verify(mScheduleRestApi).createJob(mJobFormEntity); }
@Test public void create_job_adapts_io_exception() throws Exception { when(mScheduleRestApi.createJob(any(JobFormEntity.class))).thenThrow(mIOException); try { useCase.createJob(mJobForm); fail("Should adapt IO exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mIOException); } }
@Test public void create_job_adapts_http_exception() throws Exception { when(mScheduleRestApi.createJob(any(JobFormEntity.class))).thenThrow(mHttpException); try { useCase.createJob(mJobForm); fail("Should adapt HTTP exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mHttpException); } } |
### Question:
ReportScheduleUseCase { public JobData updateJob(int id, JobForm form) throws ServiceException { return alterJob(form, id); } ReportScheduleUseCase(ServiceExceptionMapper exceptionMapper,
ReportScheduleRestApi scheduleRestApi,
InfoCacheManager cacheManager,
JobSearchCriteriaMapper searchCriteriaMapper,
JobDataMapper jobDataMapper,
JobFormMapper jobFormMapper,
JobUnitMapper jobUnitMapper
); List<JobUnit> searchJob(JobSearchCriteria criteria); JobData createJob(JobForm form); JobData updateJob(int id, JobForm form); Set<Integer> deleteJobs(Set<Integer> jobIds); JobForm readJob(int jobId); }### Answer:
@Test public void should_perform_update_job() throws Exception { when(mScheduleRestApi.updateJob(anyInt(), any(JobFormEntity.class))).thenReturn(mJobDescriptor); useCase.updateJob(JOB_ID, mJobForm); verify(mJobDataMapper).transform(mJobDescriptor, SIMPLE_DATE_FORMAT); verify(mScheduleRestApi).updateJob(JOB_ID, mJobFormEntity); } |
### Question:
ReportScheduleUseCase { public Set<Integer> deleteJobs(Set<Integer> jobIds) throws ServiceException { try { return mScheduleRestApi.deleteJobs(jobIds); } catch (IOException e) { throw mExceptionMapper.transform(e); } catch (HttpException e) { throw mExceptionMapper.transform(e); } } ReportScheduleUseCase(ServiceExceptionMapper exceptionMapper,
ReportScheduleRestApi scheduleRestApi,
InfoCacheManager cacheManager,
JobSearchCriteriaMapper searchCriteriaMapper,
JobDataMapper jobDataMapper,
JobFormMapper jobFormMapper,
JobUnitMapper jobUnitMapper
); List<JobUnit> searchJob(JobSearchCriteria criteria); JobData createJob(JobForm form); JobData updateJob(int id, JobForm form); Set<Integer> deleteJobs(Set<Integer> jobIds); JobForm readJob(int jobId); }### Answer:
@Test public void should_perform_delete_jobs() throws Exception { useCase.deleteJobs(JOB_IDS); verify(mScheduleRestApi).deleteJobs(JOB_IDS); }
@Test public void delete_jobs_adapts_io_exception() throws Exception { when(mScheduleRestApi.deleteJobs(anySetOf(Integer.class))).thenThrow(mIOException); try { useCase.deleteJobs(JOB_IDS); fail("Should adapt IO exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mIOException); } }
@Test public void delete_jobs_adapts_http_exception() throws Exception { when(mScheduleRestApi.deleteJobs(anySetOf(Integer.class))).thenThrow(mHttpException); try { useCase.deleteJobs(JOB_IDS); fail("Should adapt HTTP exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mHttpException); } } |
### Question:
ReportScheduleUseCase { public JobForm readJob(int jobId) throws ServiceException { try { JobFormEntity entity = mScheduleRestApi.requestJob(jobId); return mJobFormMapper.toDataForm(entity); } catch (IOException e) { throw mExceptionMapper.transform(e); } catch (HttpException e) { throw mExceptionMapper.transform(e); } } ReportScheduleUseCase(ServiceExceptionMapper exceptionMapper,
ReportScheduleRestApi scheduleRestApi,
InfoCacheManager cacheManager,
JobSearchCriteriaMapper searchCriteriaMapper,
JobDataMapper jobDataMapper,
JobFormMapper jobFormMapper,
JobUnitMapper jobUnitMapper
); List<JobUnit> searchJob(JobSearchCriteria criteria); JobData createJob(JobForm form); JobData updateJob(int id, JobForm form); Set<Integer> deleteJobs(Set<Integer> jobIds); JobForm readJob(int jobId); }### Answer:
@Test public void should_perform_read_job() throws Exception { when(mScheduleRestApi.requestJob(anyInt())).thenReturn(mJobFormEntity); JobForm expected = useCase.readJob(JOB_ID); assertThat(mJobForm, is(expected)); verify(mJobFormMapper).toDataForm(mJobFormEntity); verify(mScheduleRestApi).requestJob(JOB_ID); }
@Test public void read_job_adapts_io_exception() throws Exception { when(mScheduleRestApi.requestJob(anyInt())).thenThrow(mIOException); try { useCase.readJob(JOB_ID); fail("Should adapt IO exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mIOException); } }
@Test public void read_job_adapts_http_exception() throws Exception { when(mScheduleRestApi.requestJob(anyInt())).thenThrow(mHttpException); try { useCase.readJob(JOB_ID); fail("Should adapt HTTP exception"); } catch (ServiceException ex) { verify(mExceptionMapper).transform(mHttpException); } } |
### Question:
JobUnitMapper { public List<JobUnit> transform(List<JobUnitEntity> entities) { List<JobUnit> list = new ArrayList<>(entities.size()); for (JobUnitEntity entity : entities) { if (entity != null) { JobUnit unit = transform(entity); list.add(unit); } } return list; } JobUnitMapper(JobUnitDateParser jobUnitDateParser); List<JobUnit> transform(List<JobUnitEntity> entities); JobUnit transform(JobUnitEntity entity); }### Answer:
@Test public void should_map_collection_of_units() throws Exception { List<JobUnitEntity> entities = Collections.singletonList(mJobUnitEntity); List<JobUnit> expected = mJobUnitMapper.transform(entities); assertThat(expected.size(), is(1)); }
@Test public void should_map_entity_to_service_counterpart() throws Exception { JobUnit expected = mJobUnitMapper.transform(mJobUnitEntity); assertThat(expected.getId(), is(1)); assertThat(expected.getVersion(), is(100)); assertThat(expected.getLabel(), is("label")); assertThat(expected.getDescription(), is("description")); assertThat(expected.getReportUri(), is("/my/uri")); assertThat(expected.getReportLabel(), is("report label")); assertThat(expected.getOwner().toString(), is("jasperadmin|organization_1")); assertThat(expected.getState().toString(), is("NORMAL")); } |
### Question:
JobNoneTriggerMapper extends BaseTriggerMapper { @Override public void mapFormOnEntity(JobForm form, JobFormEntity entity) { JobSimpleTriggerEntity triggerEntity = new JobSimpleTriggerEntity(); mapCommonTriggerFieldsOnEntity(form, triggerEntity); triggerEntity.setOccurrenceCount(1); triggerEntity.setRecurrenceInterval(1); triggerEntity.setRecurrenceIntervalUnit("DAY"); entity.setSimpleTrigger(triggerEntity); } @Override void mapFormOnEntity(JobForm form, JobFormEntity entity); @Override void mapEntityOnForm(JobForm.Builder form, JobFormEntity entity); }### Answer:
@Test public void should_map_on_entity() throws Exception { JobFormEntity formEntity = formFactory.givenNewJobFormEntity(); JobForm form = formFactory.givenJobFormBuilderWithValues() .withStartDate(null) .build(); mapperUnderTest.mapFormOnEntity(form, formEntity); JobSimpleTriggerEntity simpleTrigger = formEntity.getSimpleTrigger(); assertThat(simpleTrigger.getOccurrenceCount(), is(1)); assertThat(simpleTrigger.getRecurrenceInterval(), is(1)); assertThat(simpleTrigger.getRecurrenceIntervalUnit(), is("DAY")); assertThat(simpleTrigger.getTimezone(), is(formFactory.provideTimeZone().getID())); assertThat(simpleTrigger.getStartType(), is(1)); }
@Test public void should_map_start_date_on_entity() throws Exception { JobFormEntity formEntity = formFactory.givenNewJobFormEntity(); JobForm form = formFactory.givenJobFormWithValues(); mapperUnderTest.mapFormOnEntity(form, formEntity); JobSimpleTriggerEntity simpleTrigger = formEntity.getSimpleTrigger(); assertThat(simpleTrigger.getStartType(), is(2)); assertThat(simpleTrigger.getStartDate(), is(formFactory.provideStartDateSrc())); } |
### Question:
JobNoneTriggerMapper extends BaseTriggerMapper { @Override public void mapEntityOnForm(JobForm.Builder form, JobFormEntity entity) { mapCommonEntityTriggerFieldsOnEntity(form, entity); } @Override void mapFormOnEntity(JobForm form, JobFormEntity entity); @Override void mapEntityOnForm(JobForm.Builder form, JobFormEntity entity); }### Answer:
@Test public void should_map_none_trigger_type_as_simple_one() throws Exception { JobForm.Builder formBuilder = formFactory.givenJobFormBuilderWithValues(); JobFormEntity jobFormEntity = formFactory.givenJobFormEntityWithValues(); JobSimpleTriggerEntity simpleTrigger = new JobSimpleTriggerEntity(); simpleTrigger.setOccurrenceCount(1); simpleTrigger.setStartDate(formFactory.provideStartDateSrc()); simpleTrigger.setTimezone(formFactory.provideTimeZone().getID()); jobFormEntity.setSimpleTrigger(simpleTrigger); mapperUnderTest.mapEntityOnForm(formBuilder, jobFormEntity); JobForm expected = formBuilder.build(); assertThat(expected.getStartDate(), is(formFactory.provideStartDate())); assertThat(expected.getTimeZone(), is(formFactory.provideTimeZone())); assertThat(expected.getTrigger(), is(nullValue())); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.