Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### 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: JCache implements net.sf.jsr107cache.Cache { public Map getAll(Collection keys) throws CacheException { return getAll(keys, null); } 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 testGetAll() throws InterruptedException, ExecutionException, CacheException { JCache jcache = new JCache(manager.getCache("sampleCache1")); Map map = jcache.getAll(null); assertNotNull(map); assertEquals(0, map.size()); CountingCacheLoader countingCacheLoader = new CountingCacheLoader(); jcache.setCacheLoader(countingCacheLoader); map = jcache.getAll(null); assertNotNull(map); assertEquals(0, map.size()); List keys = new ArrayList(); for (int i = 0; i < 1000; i++) { keys.add(new Integer(i)); } jcache.put(new Integer(1), ""); Map result = jcache.getAll(keys); Object object = result.get(new Integer(1)); assertFalse(object instanceof Element); assertEquals(1000, jcache.size()); assertEquals(999, countingCacheLoader.getLoadAllCounter()); assertFalse(result.get(new Integer(1)) == null); assertFalse(result.get(new Integer(1)) instanceof Element); }
### 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: CacheWriterConfiguration implements Cloneable { public CacheWriterConfiguration writeMode(String writeMode) { setWriteMode(writeMode); return this; } @Override CacheWriterConfiguration clone(); void setWriteMode(String writeMode); CacheWriterConfiguration writeMode(String writeMode); CacheWriterConfiguration writeMode(WriteMode writeMode); WriteMode getWriteMode(); void setNotifyListenersOnException(boolean notifyListenersOnException); CacheWriterConfiguration notifyListenersOnException(boolean notifyListenersOnException); boolean getNotifyListenersOnException(); void setMinWriteDelay(int minWriteDelay); CacheWriterConfiguration minWriteDelay(int minWriteDelay); int getMinWriteDelay(); void setMaxWriteDelay(int maxWriteDelay); CacheWriterConfiguration maxWriteDelay(int maxWriteDelay); int getMaxWriteDelay(); void setRateLimitPerSecond(int rateLimitPerSecond); CacheWriterConfiguration rateLimitPerSecond(int rateLimitPerSecond); int getRateLimitPerSecond(); void setWriteCoalescing(boolean writeCoalescing); CacheWriterConfiguration writeCoalescing(boolean writeCoalescing); boolean getWriteCoalescing(); void setWriteBatching(boolean writeBatching); CacheWriterConfiguration writeBatching(boolean writeBatching); boolean getWriteBatching(); void setWriteBatchSize(int writeBatchSize); CacheWriterConfiguration writeBatchSize(int writeBatchSize); int getWriteBatchSize(); void setRetryAttempts(int retryAttempts); CacheWriterConfiguration retryAttempts(int retryAttempts); int getRetryAttempts(); void setRetryAttemptDelaySeconds(int retryAttemptDelaySeconds); CacheWriterConfiguration retryAttemptDelaySeconds(int retryAttemptDelaySeconds); int getRetryAttemptDelaySeconds(); final void addCacheWriterFactory(CacheWriterFactoryConfiguration cacheWriterFactoryConfiguration); CacheWriterConfiguration cacheWriterFactory(CacheWriterFactoryConfiguration cacheWriterFactory); CacheWriterFactoryConfiguration getCacheWriterFactoryConfiguration(); void setWriteBehindConcurrency(int concurrency); CacheWriterConfiguration writeBehindConcurrency(int concurrency); int getWriteBehindConcurrency(); void setWriteBehindMaxQueueSize(final int writeBehindMaxQueueSize); int getWriteBehindMaxQueueSize(); CacheWriterConfiguration writeBehindMaxQueueSize(int writeBehindMaxQueueSize); @Override int hashCode(); @Override boolean equals(Object obj); void validate(Collection<ConfigError> errors); static final WriteMode DEFAULT_WRITE_MODE; static final boolean DEFAULT_NOTIFY_LISTENERS_ON_EXCEPTION; static final int DEFAULT_MIN_WRITE_DELAY; static final int DEFAULT_MAX_WRITE_DELAY; static final int DEFAULT_RATE_LIMIT_PER_SECOND; static final boolean DEFAULT_WRITE_COALESCING; static final boolean DEFAULT_WRITE_BATCHING; static final int DEFAULT_WRITE_BATCH_SIZE; static final int DEFAULT_RETRY_ATTEMPTS; static final int DEFAULT_RETRY_ATTEMPT_DELAY_SECONDS; static final int DEFAULT_WRITE_BEHIND_CONCURRENCY; static final int DEFAULT_WRITE_BEHIND_MAX_QUEUE_SIZE; }### Answer: @Test(expected = IllegalArgumentException.class) public void testNullWriteMode() { CacheWriterConfiguration config = new CacheWriterConfiguration() .writeMode((CacheWriterConfiguration.WriteMode) null); } @Test(expected = IllegalArgumentException.class) public void testInvalidWriteMode() { CacheWriterConfiguration config = new CacheWriterConfiguration() .writeMode("invalid"); }
### 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: BaseRequest extends AbstractRequest<T> { @Override @NonNull public String getBodyContentType() { if (HTTP_METHOD_JSON_ALLOWED.contains(getMethod()) && getJsonObject() != null) { return getJsonContentType(); } return super.getBodyContentType(); } 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 requestPostConstruct_contentType() throws Exception { BaseRequest.Builder<DummyResponse> builder = new BaseRequest.Builder<>(Request.Method.POST, url, DummyResponse.class); builder.json(dummyRequestObject); builder.headers(headers); BaseRequest<DummyResponse> baseRequest = builder.build(); assertTrue("The body should be json typed", baseRequest.getBodyContentType().contains("application/json")); assertNotNull(baseRequest.getBody()); } @Test public void requestPostParamConstruct_contentType() throws Exception { BaseRequest.Builder<DummyResponse> builder = new BaseRequest.Builder<>(Request.Method.POST, url, DummyResponse.class); builder.parameters(parameters); builder.headers(headers); BaseRequest<DummyResponse> baseRequest = builder.build(); assertTrue("The body should not be json typed", baseRequest.getBodyContentType().contains("application/x-www-form-urlencoded")); assertNotNull(baseRequest.getBody()); } @Test public void requestGetParamConstruct() throws Exception { BaseRequest.Builder<DummyResponse> builder = new BaseRequest.Builder<>(Request.Method.GET, url, DummyResponse.class); builder.parameters(parameters); builder.headers(headers); BaseRequest<DummyResponse> baseRequest = builder.build(); assertTrue("The body should not be json typed", baseRequest.getBodyContentType().contains("application/x-www-form-urlencoded")); assertNull(baseRequest.getBody()); } @Test public void requestPatchParamConstruct_contentType() throws Exception { BaseRequest.Builder<DummyResponse> builder = new BaseRequest.Builder<>(Request.Method.PATCH, url, DummyResponse.class); builder.parameters(parameters); builder.headers(headers); BaseRequest<DummyResponse> baseRequest = builder.build(); assertTrue("The body should not be json typed", baseRequest.getBodyContentType().contains("application/x-www-form-urlencoded")); assertNotNull(baseRequest.getBody()); }
### Question: MultipartRequest extends BaseRequest<T> { @Nullable public HashMap<String, List<RequestData>> getMultiPartData() { return multiPartData; } private MultipartRequest(Builder<T> builder); @Override @NonNull String getBodyContentType(); @Nullable HashMap<String, List<RequestData>> getMultiPartData(); @NonNull String getJsonKey(); }### Answer: @Test public void builderPostGeneration() throws Exception { MultipartRequest.Builder<DummyResponse> builder = new MultipartRequest.Builder<>(Request.Method.POST, url, DummyResponse.class); builder.parameters(parameters); builder.json(dummyRequestObject); builder.headers(headers); builder.multiPartDataList(dummyDataMap); MultipartRequest<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()); assertEquals("The parameters should be the same", parameters, baseRequest.getParams()); assertEquals("The object should be the same", dummyRequestObject, baseRequest.getJsonObject()); assertEquals("The multi part should be the same", dummyDataMap, baseRequest.getMultiPartData()); Map returnedMap = baseRequest.getHeaders(); for (String key : headers.keySet()) { assertTrue("The key should be contained", returnedMap.containsKey(key)); assertEquals("The same value should be contained", headers.get(key), returnedMap.get(key)); } } @Test public void builderPostGenerationWithPutMultipartSimple() throws Exception { MultipartRequest.Builder<DummyResponse> builder = new MultipartRequest.Builder<>(Request.Method.POST, url, DummyResponse.class); builder.parameters(parameters); builder.json(dummyRequestObject); builder.headers(headers); builder.multiPartData(dummyDataMapNoList); MultipartRequest<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()); assertEquals("The parameters should be the same", parameters, baseRequest.getParams()); assertEquals("The object should be the same", dummyRequestObject, baseRequest.getJsonObject()); assertEquals("The multi part should be the same", dummyDataMap, baseRequest.getMultiPartData()); Map returnedMap = baseRequest.getHeaders(); for (String key : headers.keySet()) { assertTrue("The key should be contained", returnedMap.containsKey(key)); assertEquals("The same value should be contained", headers.get(key), returnedMap.get(key)); } } @Test public void builderPostGenerationWithInsertMultipart() throws Exception { MultipartRequest.Builder<DummyResponse> builder = new MultipartRequest.Builder<>(Request.Method.POST, url, DummyResponse.class); builder.parameters(parameters); builder.json(dummyRequestObject); builder.headers(headers); for (Map.Entry<String, List<RequestData>> entry : dummyDataMap.entrySet()) { for (RequestData datapart : entry.getValue()) { builder.insertMultiPartData(entry.getKey(), datapart); } } MultipartRequest<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()); assertEquals("The parameters should be the same", parameters, baseRequest.getParams()); assertEquals("The object should be the same", dummyRequestObject, baseRequest.getJsonObject()); assertEquals("The multi part should be the same", dummyDataMap, baseRequest.getMultiPartData()); Map returnedMap = baseRequest.getHeaders(); for (String key : headers.keySet()) { assertTrue("The key should be contained", returnedMap.containsKey(key)); assertEquals("The same value should be contained", headers.get(key), returnedMap.get(key)); } }
### Question: JmsPoolJMSProducer implements JMSProducer { public MessageProducer getMessageProducer() throws JMSRuntimeException { try { return producer.getMessageProducer(); } catch (JMSException jmsex) { throw JMSExceptionSupport.createRuntimeException(jmsex); } } JmsPoolJMSProducer(JmsPoolSession session, JmsPoolMessageProducer producer); @Override String toString(); @Override JMSProducer send(Destination destination, Message message); @Override JMSProducer send(Destination destination, byte[] body); @Override JMSProducer send(Destination destination, Map<String, Object> body); @Override JMSProducer send(Destination destination, Serializable body); @Override JMSProducer send(Destination destination, String body); @Override JMSProducer clearProperties(); @Override Set<String> getPropertyNames(); @Override boolean propertyExists(String name); @Override boolean getBooleanProperty(String name); @Override byte getByteProperty(String name); @Override double getDoubleProperty(String name); @Override float getFloatProperty(String name); @Override int getIntProperty(String name); @Override long getLongProperty(String name); @Override Object getObjectProperty(String name); @Override short getShortProperty(String name); @Override String getStringProperty(String name); @Override JMSProducer setProperty(String name, boolean value); @Override JMSProducer setProperty(String name, byte value); @Override JMSProducer setProperty(String name, double value); @Override JMSProducer setProperty(String name, float value); @Override JMSProducer setProperty(String name, int value); @Override JMSProducer setProperty(String name, long value); @Override JMSProducer setProperty(String name, Object value); @Override JMSProducer setProperty(String name, short value); @Override JMSProducer setProperty(String name, String value); @Override String getJMSCorrelationID(); @Override JMSProducer setJMSCorrelationID(String correlationId); @Override byte[] getJMSCorrelationIDAsBytes(); @Override JMSProducer setJMSCorrelationIDAsBytes(byte[] correlationIdBytes); @Override Destination getJMSReplyTo(); @Override JMSProducer setJMSReplyTo(Destination replyTo); @Override String getJMSType(); @Override JMSProducer setJMSType(String type); @Override CompletionListener getAsync(); @Override JMSProducer setAsync(CompletionListener completionListener); @Override long getDeliveryDelay(); @Override JMSProducer setDeliveryDelay(long deliveryDelay); @Override int getDeliveryMode(); @Override JMSProducer setDeliveryMode(int deliveryMode); @Override boolean getDisableMessageID(); @Override JMSProducer setDisableMessageID(boolean disableMessageId); @Override boolean getDisableMessageTimestamp(); @Override JMSProducer setDisableMessageTimestamp(boolean disableTimestamp); @Override int getPriority(); @Override JMSProducer setPriority(int priority); @Override long getTimeToLive(); @Override JMSProducer setTimeToLive(long timeToLive); MessageProducer getMessageProducer(); }### Answer: @Test(timeout = 30000) public void testCreateJMSProducer() throws JMSException { JmsPoolJMSProducer producer = (JmsPoolJMSProducer) context.createProducer(); assertNotNull(producer); MockJMSMessageProducer mockProducer = (MockJMSMessageProducer) producer.getMessageProducer(); assertNotNull(mockProducer); assertNull(mockProducer.getDestination()); context.close(); try { producer.getMessageProducer(); fail("should throw on closed context."); } catch (JMSRuntimeException jmsre) {} }
### 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: JmsPoolJMSProducer implements JMSProducer { @Override public double getDoubleProperty(String name) { try { return convertPropertyTo(name, messageProperties.get(name), Double.class); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSProducer(JmsPoolSession session, JmsPoolMessageProducer producer); @Override String toString(); @Override JMSProducer send(Destination destination, Message message); @Override JMSProducer send(Destination destination, byte[] body); @Override JMSProducer send(Destination destination, Map<String, Object> body); @Override JMSProducer send(Destination destination, Serializable body); @Override JMSProducer send(Destination destination, String body); @Override JMSProducer clearProperties(); @Override Set<String> getPropertyNames(); @Override boolean propertyExists(String name); @Override boolean getBooleanProperty(String name); @Override byte getByteProperty(String name); @Override double getDoubleProperty(String name); @Override float getFloatProperty(String name); @Override int getIntProperty(String name); @Override long getLongProperty(String name); @Override Object getObjectProperty(String name); @Override short getShortProperty(String name); @Override String getStringProperty(String name); @Override JMSProducer setProperty(String name, boolean value); @Override JMSProducer setProperty(String name, byte value); @Override JMSProducer setProperty(String name, double value); @Override JMSProducer setProperty(String name, float value); @Override JMSProducer setProperty(String name, int value); @Override JMSProducer setProperty(String name, long value); @Override JMSProducer setProperty(String name, Object value); @Override JMSProducer setProperty(String name, short value); @Override JMSProducer setProperty(String name, String value); @Override String getJMSCorrelationID(); @Override JMSProducer setJMSCorrelationID(String correlationId); @Override byte[] getJMSCorrelationIDAsBytes(); @Override JMSProducer setJMSCorrelationIDAsBytes(byte[] correlationIdBytes); @Override Destination getJMSReplyTo(); @Override JMSProducer setJMSReplyTo(Destination replyTo); @Override String getJMSType(); @Override JMSProducer setJMSType(String type); @Override CompletionListener getAsync(); @Override JMSProducer setAsync(CompletionListener completionListener); @Override long getDeliveryDelay(); @Override JMSProducer setDeliveryDelay(long deliveryDelay); @Override int getDeliveryMode(); @Override JMSProducer setDeliveryMode(int deliveryMode); @Override boolean getDisableMessageID(); @Override JMSProducer setDisableMessageID(boolean disableMessageId); @Override boolean getDisableMessageTimestamp(); @Override JMSProducer setDisableMessageTimestamp(boolean disableTimestamp); @Override int getPriority(); @Override JMSProducer setPriority(int priority); @Override long getTimeToLive(); @Override JMSProducer setTimeToLive(long timeToLive); MessageProducer getMessageProducer(); }### Answer: @Test public void testGetDoubleProperty() { JMSProducer producer = context.createProducer(); producer.setProperty(DOUBLE_PROPERTY_NAME, DOUBLE_PROPERTY_VALUE); assertEquals(DOUBLE_PROPERTY_VALUE, producer.getDoubleProperty(DOUBLE_PROPERTY_NAME), 0.0); }
### Question: JmsPoolJMSProducer implements JMSProducer { @Override public float getFloatProperty(String name) { try { return convertPropertyTo(name, messageProperties.get(name), Float.class); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSProducer(JmsPoolSession session, JmsPoolMessageProducer producer); @Override String toString(); @Override JMSProducer send(Destination destination, Message message); @Override JMSProducer send(Destination destination, byte[] body); @Override JMSProducer send(Destination destination, Map<String, Object> body); @Override JMSProducer send(Destination destination, Serializable body); @Override JMSProducer send(Destination destination, String body); @Override JMSProducer clearProperties(); @Override Set<String> getPropertyNames(); @Override boolean propertyExists(String name); @Override boolean getBooleanProperty(String name); @Override byte getByteProperty(String name); @Override double getDoubleProperty(String name); @Override float getFloatProperty(String name); @Override int getIntProperty(String name); @Override long getLongProperty(String name); @Override Object getObjectProperty(String name); @Override short getShortProperty(String name); @Override String getStringProperty(String name); @Override JMSProducer setProperty(String name, boolean value); @Override JMSProducer setProperty(String name, byte value); @Override JMSProducer setProperty(String name, double value); @Override JMSProducer setProperty(String name, float value); @Override JMSProducer setProperty(String name, int value); @Override JMSProducer setProperty(String name, long value); @Override JMSProducer setProperty(String name, Object value); @Override JMSProducer setProperty(String name, short value); @Override JMSProducer setProperty(String name, String value); @Override String getJMSCorrelationID(); @Override JMSProducer setJMSCorrelationID(String correlationId); @Override byte[] getJMSCorrelationIDAsBytes(); @Override JMSProducer setJMSCorrelationIDAsBytes(byte[] correlationIdBytes); @Override Destination getJMSReplyTo(); @Override JMSProducer setJMSReplyTo(Destination replyTo); @Override String getJMSType(); @Override JMSProducer setJMSType(String type); @Override CompletionListener getAsync(); @Override JMSProducer setAsync(CompletionListener completionListener); @Override long getDeliveryDelay(); @Override JMSProducer setDeliveryDelay(long deliveryDelay); @Override int getDeliveryMode(); @Override JMSProducer setDeliveryMode(int deliveryMode); @Override boolean getDisableMessageID(); @Override JMSProducer setDisableMessageID(boolean disableMessageId); @Override boolean getDisableMessageTimestamp(); @Override JMSProducer setDisableMessageTimestamp(boolean disableTimestamp); @Override int getPriority(); @Override JMSProducer setPriority(int priority); @Override long getTimeToLive(); @Override JMSProducer setTimeToLive(long timeToLive); MessageProducer getMessageProducer(); }### Answer: @Test public void testGetFloatProperty() { JMSProducer producer = context.createProducer(); producer.setProperty(FLOAT_PROPERTY_NAME, FLOAT_PROPERTY_VALUE); assertEquals(FLOAT_PROPERTY_VALUE, producer.getFloatProperty(FLOAT_PROPERTY_NAME), 0.0f); }
### Question: JMSMessagePropertySupport { @SuppressWarnings("unchecked") public static <T> T convertPropertyTo(String name, Object value, Class<T> target) throws JMSException { if (value == null) { if (Boolean.class.equals(target)) { return (T) Boolean.FALSE; } else if (Float.class.equals(target) \|\| Double.class.equals(target)) { throw new NullPointerException("property " + name + " was null"); } else if (Number.class.isAssignableFrom(target)) { throw new NumberFormatException("property " + name + " was null"); } else { return null; } } T rc = (T) TypeConversionSupport.convert(value, target); if (rc == null) { throw new MessageFormatException("Property " + name + " was a " + value.getClass().getName() + " and cannot be read as a " + target.getName()); } return rc; } @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 testConvertPropertyToNullBooleanTarget() throws JMSException { assertFalse(JMSMessagePropertySupport.convertPropertyTo("timeout", null, Boolean.class)); } @Test(expected = NullPointerException.class) public void testConvertPropertyToNullFloatTarget() throws JMSException { JMSMessagePropertySupport.convertPropertyTo("float", null, Float.class); } @Test(expected = NullPointerException.class) public void testConvertPropertyToNullDoubleTarget() throws JMSException { JMSMessagePropertySupport.convertPropertyTo("double", null, Double.class); } @Test(expected = NumberFormatException.class) public void testConvertPropertyToNullShortTarget() throws JMSException { JMSMessagePropertySupport.convertPropertyTo("number", null, Short.class); } @Test(expected = NumberFormatException.class) public void testConvertPropertyToNullIntegerTarget() throws JMSException { JMSMessagePropertySupport.convertPropertyTo("number", null, Integer.class); } @Test(expected = NumberFormatException.class) public void testConvertPropertyToNullLongTarget() throws JMSException { JMSMessagePropertySupport.convertPropertyTo("number", null, Long.class); } @Test public void testConvertPropertyToNullStringTarget() throws JMSException { assertNull(JMSMessagePropertySupport.convertPropertyTo("string", null, String.class)); }
### 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 checkIdentifierIsntLogicOperator(String identifier) { if ("NOT".equals(identifier) \|\| "AND".equals(identifier) \|\| "OR".equals(identifier) \|\| "BETWEEN".equals(identifier) \|\| "LIKE".equals(identifier) \|\| "IN".equals(identifier) \|\| "IS".equals(identifier) \|\| "ESCAPE".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 testCheckIdentifierIsntLogicOperatorOr() throws JMSException { JMSMessagePropertySupport.checkIdentifierIsntLogicOperator("OR"); } @Test(expected = IllegalArgumentException.class) public void testCheckIdentifierIsntLogicOperatorAnd() throws JMSException { JMSMessagePropertySupport.checkIdentifierIsntLogicOperator("AND"); } @Test(expected = IllegalArgumentException.class) public void testCheckIdentifierIsntLogicOperatorNot() throws JMSException { JMSMessagePropertySupport.checkIdentifierIsntLogicOperator("NOT"); } @Test(expected = IllegalArgumentException.class) public void testCheckIdentifierIsntLogicOperatorBetween() throws JMSException { JMSMessagePropertySupport.checkIdentifierIsntLogicOperator("BETWEEN"); } @Test(expected = IllegalArgumentException.class) public void testCheckIdentifierIsntLogicOperatorIn() throws JMSException { JMSMessagePropertySupport.checkIdentifierIsntLogicOperator("IN"); } @Test(expected = IllegalArgumentException.class) public void testCheckIdentifierIsntLogicOperatorLike() throws JMSException { JMSMessagePropertySupport.checkIdentifierIsntLogicOperator("LIKE"); } @Test(expected = IllegalArgumentException.class) public void testCheckIdentifierIsntLogicOperatorIs() throws JMSException { JMSMessagePropertySupport.checkIdentifierIsntLogicOperator("IS"); } @Test(expected = IllegalArgumentException.class) public void testCheckIdentifierIsntLogicOperatorEscape() throws JMSException { JMSMessagePropertySupport.checkIdentifierIsntLogicOperator("ESCAPE"); }
### 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: JMSMessagePropertySupport { public static void checkValidObject(Object value) throws MessageFormatException { boolean valid = value instanceof Boolean \|\| value instanceof Byte \|\| value instanceof Short \|\| value instanceof Integer \|\| value instanceof Long \|\| value instanceof Float \|\| value instanceof Double \|\| value instanceof Character \|\| value instanceof String \|\| value == null; if (!valid) { throw new MessageFormatException("Only objectified primitive objects and String types are allowed but was: " + value + " type: " + value.getClass()); } } @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 testCheckValidObjectBoolean() throws JMSException { JMSMessagePropertySupport.checkValidObject(Boolean.TRUE); } @Test public void testCheckValidObjectByte() throws JMSException { JMSMessagePropertySupport.checkValidObject(Byte.MAX_VALUE); } @Test public void testCheckValidObjectShort() throws JMSException { JMSMessagePropertySupport.checkValidObject(Short.MAX_VALUE); } @Test public void testCheckValidObjectInteger() throws JMSException { JMSMessagePropertySupport.checkValidObject(Integer.MAX_VALUE); } @Test public void testCheckValidObjectLong() throws JMSException { JMSMessagePropertySupport.checkValidObject(Long.MAX_VALUE); } @Test public void testCheckValidObjectFloat() throws JMSException { JMSMessagePropertySupport.checkValidObject(Float.MAX_VALUE); } @Test public void testCheckValidObjectDouble() throws JMSException { JMSMessagePropertySupport.checkValidObject(Double.MAX_VALUE); } @Test public void testCheckValidObjectCharacter() throws JMSException { JMSMessagePropertySupport.checkValidObject(Character.MAX_VALUE); } @Test public void testCheckValidObjectString() throws JMSException { JMSMessagePropertySupport.checkValidObject(""); } @Test public void testCheckValidObjectNull() throws JMSException { JMSMessagePropertySupport.checkValidObject(null); } @Test(expected = MessageFormatException.class) public void testCheckValidObjectList() throws JMSException { JMSMessagePropertySupport.checkValidObject(Collections.EMPTY_LIST); }
### 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: JmsPoolMessageProducer implements MessageProducer, AutoCloseable { @Override public void setDeliveryMode(int deliveryMode) throws JMSException { checkClosed(); this.deliveryMode = deliveryMode; } 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 testSetDeliveryMode() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageProducer producer = session.createProducer(queue); assertEquals(Message.DEFAULT_DELIVERY_MODE, producer.getDeliveryMode()); producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT); assertEquals(DeliveryMode.NON_PERSISTENT, producer.getDeliveryMode()); producer.close(); try { producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT); fail("Should throw when producer is closed."); } catch (IllegalStateException ise) {} try { producer.getDeliveryMode(); fail("Should throw when producer is closed."); } catch (IllegalStateException ise) {} }
### Question: JmsPoolMessageProducer implements MessageProducer, AutoCloseable { @Override public void setDeliveryDelay(long deliveryDelay) throws JMSException { checkClosed(); session.checkClientJMSVersionSupport(2, 0); this.deliveryDelay = deliveryDelay; this.messageProducer.setDeliveryDelay(deliveryDelay); } 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 testSetDeliveryDelay() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageProducer producer = session.createProducer(queue); assertEquals(0, producer.getDeliveryDelay()); producer.setDeliveryDelay(1); assertEquals(1, producer.getDeliveryDelay()); producer.close(); try { producer.setDeliveryDelay(0); fail("Should throw when producer is closed."); } catch (IllegalStateException ise) {} try { producer.getDeliveryDelay(); fail("Should throw when producer is closed."); } catch (IllegalStateException ise) {} }
### Question: JmsPoolMessageProducer implements MessageProducer, AutoCloseable { @Override public void setPriority(int priority) throws JMSException { checkClosed(); this.priority = priority; } 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 testSetPriority() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageProducer producer = session.createProducer(queue); assertEquals(Message.DEFAULT_PRIORITY, producer.getPriority()); producer.setPriority(1); assertEquals(1, producer.getPriority()); producer.close(); try { producer.setPriority(0); fail("Should throw when producer is closed."); } catch (IllegalStateException ise) {} try { producer.getPriority(); fail("Should throw when producer is closed."); } catch (IllegalStateException ise) {} }
### Question: JmsPoolMessageProducer implements MessageProducer, AutoCloseable { @Override public void setTimeToLive(long timeToLive) throws JMSException { checkClosed(); this.timeToLive = timeToLive; } 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 testSetTimeToLive() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageProducer producer = session.createProducer(queue); assertEquals(Message.DEFAULT_TIME_TO_LIVE, producer.getTimeToLive()); producer.setTimeToLive(1); assertEquals(1, producer.getTimeToLive()); producer.close(); try { producer.setTimeToLive(0); fail("Should throw when producer is closed."); } catch (IllegalStateException ise) {} try { producer.getTimeToLive(); fail("Should throw when producer is closed."); } catch (IllegalStateException ise) {} }
### Question: JmsPoolMessageProducer implements MessageProducer, AutoCloseable { @Override public void setDisableMessageID(boolean disableMessageID) throws JMSException { checkClosed(); this.disableMessageID = disableMessageID; } 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 testSetDisableMessageID() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createQueueConnection(); Session session = connection.createSession(); Queue queue = session.createTemporaryQueue(); MessageProducer producer = session.createProducer(queue); assertFalse(producer.getDisableMessageID()); producer.setDisableMessageID(true); assertTrue(producer.getDisableMessageID()); producer.close(); try { producer.setDisableMessageID(false); fail("Should throw when producer is closed."); } catch (IllegalStateException ise) {} try { producer.getDisableMessageID(); fail("Should throw when producer is closed."); } catch (IllegalStateException ise) {} }
### 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: JmsPoolQueueSender extends JmsPoolMessageProducer implements QueueSender, AutoCloseable { @Override public void send(Queue queue, Message message, int deliveryMode, int priority, long timeToLine) throws JMSException { super.send(queue, message, deliveryMode, priority, timeToLine); } 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 testSendToQueue() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createTopicConnection(); QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createTemporaryQueue(); QueueSender sender = session.createSender(null); final AtomicBoolean sent = new AtomicBoolean(); MockJMSConnection mockConnection = (MockJMSConnection) connection.getConnection(); mockConnection.addConnectionListener(new MockJMSDefaultConnectionListener() { @Override public void onMessageSend(MockJMSSession session, MockJMSMessageProducer producer, Message message) throws JMSException { assertTrue(message instanceof TextMessage); sent.set(true); } }); sender.send(queue, session.createTextMessage()); assertTrue(sent.get()); } @Test public void testSendToQueueWithOverrides() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createTopicConnection(); QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createTemporaryQueue(); QueueSender sender = session.createSender(null); final AtomicBoolean sent = new AtomicBoolean(); MockJMSConnection mockConnection = (MockJMSConnection) connection.getConnection(); mockConnection.addConnectionListener(new MockJMSDefaultConnectionListener() { @Override public void onMessageSend(MockJMSSession session, MockJMSMessageProducer producer, Message message) throws JMSException { assertEquals(DeliveryMode.PERSISTENT, message.getJMSDeliveryMode()); assertEquals(9, message.getJMSPriority()); assertTrue(message.getJMSExpiration() != 0); sent.set(true); } }); sender.send(queue, session.createTextMessage(), DeliveryMode.PERSISTENT, 9, 100); assertTrue(sent.get()); } @Test public void testSendToQueueFailsIfNotAnonymousPublisher() throws JMSException { JmsPoolConnection connection = (JmsPoolConnection) cf.createTopicConnection(); QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE); Queue queue = session.createTemporaryQueue(); QueueSender sender = session.createSender(queue); try { sender.send(session.createTemporaryQueue(), session.createTextMessage()); fail("Should not be able to send to alternate destination"); } catch (UnsupportedOperationException ex) {} }
### 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 void stop() { if (stopped.compareAndSet(false, true)) { LOG.debug("Stopping the JmsPoolConnectionFactory, number of connections in cache: {}", connectionsPool != null ? connectionsPool.getNumActive() : 0); try { if (connectionsPool != null) { connectionsPool.close(); connectionsPool = null; } } catch (Exception ignored) { LOG.trace("Caught exception on close of the Connection pool: ", ignored); } } } 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 testInstanceOf() throws Exception { cf = new JmsPoolConnectionFactory(); assertTrue(cf instanceof QueueConnectionFactory); assertTrue(cf instanceof TopicConnectionFactory); cf.stop(); }
### 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 { public void setConnectionFactory(final Object factory) { if (factory instanceof ConnectionFactory) { String logMessage = "JMS ConnectionFactory on classpath is not a JMS 2.0+ version."; try { ConnectionFactory.class.getMethod("createContext", int.class); logMessage = "Provided ConnectionFactory implementation is not JMS 2.0+ capable."; factory.getClass().getMethod("createContext", int.class); logMessage = "Provided ConnectionFactory implementation is JMS 2.0+ capable."; jmsContextSupported = true; } catch (NoSuchMethodException \| SecurityException e) { } finally { LOG.info(logMessage); } this.connectionFactory = factory; } else { throw new IllegalArgumentException("connectionFactory should implement javax.jms.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(expected = IllegalArgumentException.class) public void testFactoryRejectsNonConnectionFactorySet() throws Exception { cf.setConnectionFactory(""); }
### 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: JmsPoolJMSProducer implements JMSProducer { @Override public String toString() { return getClass().getSimpleName() + " { " + producer + " }"; } JmsPoolJMSProducer(JmsPoolSession session, JmsPoolMessageProducer producer); @Override String toString(); @Override JMSProducer send(Destination destination, Message message); @Override JMSProducer send(Destination destination, byte[] body); @Override JMSProducer send(Destination destination, Map<String, Object> body); @Override JMSProducer send(Destination destination, Serializable body); @Override JMSProducer send(Destination destination, String body); @Override JMSProducer clearProperties(); @Override Set<String> getPropertyNames(); @Override boolean propertyExists(String name); @Override boolean getBooleanProperty(String name); @Override byte getByteProperty(String name); @Override double getDoubleProperty(String name); @Override float getFloatProperty(String name); @Override int getIntProperty(String name); @Override long getLongProperty(String name); @Override Object getObjectProperty(String name); @Override short getShortProperty(String name); @Override String getStringProperty(String name); @Override JMSProducer setProperty(String name, boolean value); @Override JMSProducer setProperty(String name, byte value); @Override JMSProducer setProperty(String name, double value); @Override JMSProducer setProperty(String name, float value); @Override JMSProducer setProperty(String name, int value); @Override JMSProducer setProperty(String name, long value); @Override JMSProducer setProperty(String name, Object value); @Override JMSProducer setProperty(String name, short value); @Override JMSProducer setProperty(String name, String value); @Override String getJMSCorrelationID(); @Override JMSProducer setJMSCorrelationID(String correlationId); @Override byte[] getJMSCorrelationIDAsBytes(); @Override JMSProducer setJMSCorrelationIDAsBytes(byte[] correlationIdBytes); @Override Destination getJMSReplyTo(); @Override JMSProducer setJMSReplyTo(Destination replyTo); @Override String getJMSType(); @Override JMSProducer setJMSType(String type); @Override CompletionListener getAsync(); @Override JMSProducer setAsync(CompletionListener completionListener); @Override long getDeliveryDelay(); @Override JMSProducer setDeliveryDelay(long deliveryDelay); @Override int getDeliveryMode(); @Override JMSProducer setDeliveryMode(int deliveryMode); @Override boolean getDisableMessageID(); @Override JMSProducer setDisableMessageID(boolean disableMessageId); @Override boolean getDisableMessageTimestamp(); @Override JMSProducer setDisableMessageTimestamp(boolean disableTimestamp); @Override int getPriority(); @Override JMSProducer setPriority(int priority); @Override long getTimeToLive(); @Override JMSProducer setTimeToLive(long timeToLive); MessageProducer getMessageProducer(); }### Answer: @Test(timeout = 30000) public void testToString() throws JMSException { JMSProducer producer = context.createProducer(); assertNotNull(producer.toString()); }
### 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: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public synchronized JMSContext createContext(int sessionMode) { if (connectionRefCount.get() == 0) { throw new IllegalStateRuntimeException("The Connection is closed"); } validateSessionMode(sessionMode); connectionRefCount.incrementAndGet(); return new JmsPoolJMSContext(connection, sessionMode, connectionRefCount); } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateContextCreatesConnection() { JMSContext context = cf.createContext(); assertNotNull(context); assertTrue(context instanceof JmsPoolJMSContext); assertEquals(1, cf.getNumConnections()); } @Test(timeout = 30000) public void testCreateSubContextWithInvalidSessionMode() { JMSContext context = cf.createContext(); try { context.createContext(9); fail("Should not be able to call with invalid mode."); } catch (JMSRuntimeException jmsre) {} } @Test(timeout = 30000) public void testCreateContextOptOutConfiguration() { cf.setUseProviderJMSContext(true); JMSContext context = cf.createContext(); assertNotNull(context); assertFalse(context instanceof JmsPoolJMSContext); assertTrue(context instanceof MockJMSContext); assertEquals(0, cf.getNumConnections()); } @Test(timeout = 30000) public void testCreateContextOptOutConfigurationWithCredentials() { cf.setUseProviderJMSContext(true); JMSContext context = cf.createContext("user", "password"); assertNotNull(context); assertFalse(context instanceof JmsPoolJMSContext); assertTrue(context instanceof MockJMSContext); assertEquals(0, cf.getNumConnections()); } @Test(timeout = 30000) public void testCreateContextOptOutConfigurationUserName() { cf.setUseProviderJMSContext(true); JMSContext context = cf.createContext("user", null); assertNotNull(context); assertFalse(context instanceof JmsPoolJMSContext); assertTrue(context instanceof MockJMSContext); assertEquals(0, cf.getNumConnections()); }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public String toString() { return getClass().getSimpleName() + " { " + connection + " }"; } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testToString() { JMSContext context = cf.createContext(); assertNotNull(context.toString()); }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public ConnectionMetaData getMetaData() { try { return connection.getMetaData(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testGetMetaData() { JMSContext context = cf.createContext(); assertNotNull(context.getMetaData()); context.close(); try { context.getMetaData(); fail("Should not be able to get MetaData from closed."); } catch (JMSRuntimeException jmsre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public String getClientID() { try { return connection.getClientID(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testGetClientID() { JMSContext context = cf.createContext(); assertNotNull(context.getClientID()); context.close(); try { context.getClientID(); fail("Should not be able to get ClientID from closed."); } catch (JMSRuntimeException jmsre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public ExceptionListener getExceptionListener() { try { return connection.getExceptionListener(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testGetExceptionListener() { JMSContext context = cf.createContext(); assertNull(context.getExceptionListener()); context.setExceptionListener(new ExceptionListener() { @Override public void onException(JMSException exception) { } }); assertNotNull(context.getExceptionListener()); context.close(); try { context.getExceptionListener(); fail("Should not be able to get ExceptionListener from closed."); } catch (JMSRuntimeException jmsre) {} try { context.setExceptionListener(new ExceptionListener() { @Override public void onException(JMSException exception) { } }); fail("Should not be able to set ExceptionListener from closed."); } catch (JMSRuntimeException jmsre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public Queue createQueue(String queueName) { try { return getSession().createQueue(queueName); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateQueue() { JMSContext context = cf.createContext(); assertNotNull(context.createQueue(getTestName())); context.close(); try { context.createQueue(getTestName()); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public TemporaryQueue createTemporaryQueue() { try { return getSession().createTemporaryQueue(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateTemporaryQueue() { JMSContext context = cf.createContext(); assertNotNull(context.createTemporaryQueue()); context.close(); try { context.createTemporaryQueue(); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public Topic createTopic(String topicName) { try { return getSession().createTopic(topicName); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateTopic() { JMSContext context = cf.createContext(); assertNotNull(context.createTopic(getTestName())); context.close(); try { context.createTopic(getTestName()); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public TemporaryTopic createTemporaryTopic() { try { return getSession().createTemporaryTopic(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateTemporaryTopic() { JMSContext context = cf.createContext(); assertNotNull(context.createTemporaryTopic()); context.close(); try { context.createTemporaryTopic(); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public Message createMessage() { try { return getSession().createMessage(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateMessage() { JMSContext context = cf.createContext(); assertNotNull(context.createMessage()); context.close(); try { context.createMessage(); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public BytesMessage createBytesMessage() { try { return getSession().createBytesMessage(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateBytesMessage() { JMSContext context = cf.createContext(); assertNotNull(context.createBytesMessage()); context.close(); try { context.createBytesMessage(); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public MapMessage createMapMessage() { try { return getSession().createMapMessage(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateMapMessage() { JMSContext context = cf.createContext(); assertNotNull(context.createMapMessage()); context.close(); try { context.createMapMessage(); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public ObjectMessage createObjectMessage() { try { return getSession().createObjectMessage(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateObjectMessage() { JMSContext context = cf.createContext(); assertNotNull(context.createObjectMessage()); context.close(); try { context.createObjectMessage(); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public TextMessage createTextMessage() { try { return getSession().createTextMessage(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateTextMessage() { JMSContext context = cf.createContext(); assertNotNull(context.createTextMessage()); context.close(); try { context.createTextMessage(); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public JMSProducer createProducer() { if (connectionRefCount.get() == 0) { throw new IllegalStateRuntimeException("The Connection is closed"); } try { if (sharedProducer == null) { synchronized (this) { if (sharedProducer == null) { sharedProducer = (JmsPoolMessageProducer) getSession().createProducer(null); } } } return new JmsPoolJMSProducer(getSession(), sharedProducer); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateProducer() { JMSContext context = cf.createContext(); assertNotNull(context.createProducer()); assertNotNull(context.createProducer()); context.close(); try { context.createProducer(); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public QueueBrowser createBrowser(Queue queue) { try { return startIfNeeded(getSession().createBrowser(queue)); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateBrowser() { JMSContext context = cf.createContext(); Queue queue = context.createQueue(getTestName()); assertNotNull(context.createBrowser(queue)); context.close(); try { context.createBrowser(queue); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public JMSConsumer createConsumer(Destination destination) { try { return startIfNeeded(new JmsPoolJMSConsumer((JmsPoolMessageConsumer) getSession().createConsumer(destination))); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateConsumer() { JMSContext context = cf.createContext(); Queue queue = context.createQueue(getTestName()); assertNotNull(context.createConsumer(queue)); context.close(); try { context.createConsumer(queue); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public JMSConsumer createDurableConsumer(Topic topic, String name) { try { return startIfNeeded(new JmsPoolJMSConsumer((JmsPoolMessageConsumer) getSession().createDurableConsumer(topic, name))); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateDurableConsumer() { JMSContext context = cf.createContext(); Topic topic = context.createTopic(getTestName()); assertNotNull(context.createDurableConsumer(topic, "test")); context.close(); try { context.createDurableConsumer(topic, "test"); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public JMSConsumer createSharedDurableConsumer(Topic topic, String name) { try { return startIfNeeded(new JmsPoolJMSConsumer((JmsPoolMessageConsumer) getSession().createSharedDurableConsumer(topic, name))); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCreateSharedDurableConsumer() { JMSContext context = cf.createContext(); Topic topic = context.createTopic(getTestName()); assertNotNull(context.createSharedDurableConsumer(topic, "test")); context.close(); try { context.createSharedDurableConsumer(topic, "test"); fail("Should not be able to create resource when context is closed"); } catch (IllegalStateRuntimeException isre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public boolean getTransacted() { return sessionMode == JMSContext.SESSION_TRANSACTED; } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testGetTransacted() { JmsPoolJMSContext context1 = (JmsPoolJMSContext) cf.createContext(); JmsPoolJMSContext context2 = (JmsPoolJMSContext) context1.createContext(Session.SESSION_TRANSACTED); assertFalse(context1.getTransacted()); assertTrue(context2.getTransacted()); }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public void commit() { try { getSession().commit(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testCommit() { JmsPoolJMSContext context1 = (JmsPoolJMSContext) cf.createContext(); JmsPoolJMSContext context2 = (JmsPoolJMSContext) context1.createContext(Session.SESSION_TRANSACTED); try { context1.commit(); fail("Cannot commit a non-TX session"); } catch (JMSRuntimeException jmsre) {} context2.commit(); }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public void rollback() { try { getSession().rollback(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testRollback() { JmsPoolJMSContext context1 = (JmsPoolJMSContext) cf.createContext(); JmsPoolJMSContext context2 = (JmsPoolJMSContext) context1.createContext(Session.SESSION_TRANSACTED); try { context1.rollback(); fail("Cannot rollback a non-TX session"); } catch (JMSRuntimeException jmsre) {} context2.rollback(); }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public void recover() { try { getSession().recover(); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testRecover() { JmsPoolJMSContext context = (JmsPoolJMSContext) cf.createContext(); context.recover(); context.close(); try { context.recover(); fail("Cannot recover from a closed resource"); } catch (JMSRuntimeException jmsre) {} }
### Question: JmsPoolJMSContext implements JMSContext, AutoCloseable { @Override public void unsubscribe(String name) { try { getSession().unsubscribe(name); } catch (JMSException jmse) { throw JMSExceptionSupport.createRuntimeException(jmse); } } JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode); private JmsPoolJMSContext(JmsPoolConnection connection, int sessionMode, AtomicLong connectionRefCount); @Override void start(); @Override void stop(); @Override synchronized void close(); @Override void acknowledge(); @Override void commit(); @Override void rollback(); @Override void recover(); @Override void unsubscribe(String name); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable object); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String text); @Override Queue createQueue(String queueName); @Override Topic createTopic(String topicName); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override synchronized JMSContext createContext(int sessionMode); @Override JMSProducer createProducer(); @Override JMSConsumer createConsumer(Destination destination); @Override JMSConsumer createConsumer(Destination destination, String selector); @Override JMSConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override JMSConsumer createDurableConsumer(Topic topic, String name); @Override JMSConsumer createDurableConsumer(Topic topic, String name, String selector, boolean noLocal); @Override JMSConsumer createSharedConsumer(Topic topic, String name); @Override JMSConsumer createSharedConsumer(Topic topic, String name, String selector); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name); @Override JMSConsumer createSharedDurableConsumer(Topic topic, String name, String selector); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override boolean getAutoStart(); @Override void setAutoStart(boolean autoStart); @Override String getClientID(); @Override void setClientID(String clientID); @Override ExceptionListener getExceptionListener(); @Override void setExceptionListener(ExceptionListener listener); @Override ConnectionMetaData getMetaData(); @Override int getSessionMode(); @Override boolean getTransacted(); @Override String toString(); Connection getConnection(); }### Answer: @Test(timeout = 30000) public void testUnsubscribe() { JmsPoolJMSContext context = (JmsPoolJMSContext) cf.createContext(); context.unsubscribe("sub"); context.close(); try { context.unsubscribe("sub"); fail("Cannot unsubscribe from a closed resource"); } catch (JMSRuntimeException jmsre) {} }
### 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: JmsPoolConnection implements TopicConnection, QueueConnection, JmsPoolSessionEventListener, AutoCloseable { @Override public Session createSession() throws JMSException { return createSession(false, Session.AUTO_ACKNOWLEDGE); } 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 testCreateSession() throws Exception { Connection connection = cf.createConnection(); Session session1 = connection.createSession(); Session session2 = connection.createSession(); assertNotSame(session1, session2); assertEquals(session1.getAcknowledgeMode(), Session.AUTO_ACKNOWLEDGE); assertEquals(session2.getAcknowledgeMode(), Session.AUTO_ACKNOWLEDGE); JmsPoolSession wrapperSession1 = (JmsPoolSession) session1; JmsPoolSession wrapperSession2 = (JmsPoolSession) session2; assertNotSame(wrapperSession1.getSession(), wrapperSession2.getSession()); }
### 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: JmsPoolJMSProducer implements JMSProducer { @Override public Set<String> getPropertyNames() { return new HashSet<String>(messageProperties.keySet()); } JmsPoolJMSProducer(JmsPoolSession session, JmsPoolMessageProducer producer); @Override String toString(); @Override JMSProducer send(Destination destination, Message message); @Override JMSProducer send(Destination destination, byte[] body); @Override JMSProducer send(Destination destination, Map<String, Object> body); @Override JMSProducer send(Destination destination, Serializable body); @Override JMSProducer send(Destination destination, String body); @Override JMSProducer clearProperties(); @Override Set<String> getPropertyNames(); @Override boolean propertyExists(String name); @Override boolean getBooleanProperty(String name); @Override byte getByteProperty(String name); @Override double getDoubleProperty(String name); @Override float getFloatProperty(String name); @Override int getIntProperty(String name); @Override long getLongProperty(String name); @Override Object getObjectProperty(String name); @Override short getShortProperty(String name); @Override String getStringProperty(String name); @Override JMSProducer setProperty(String name, boolean value); @Override JMSProducer setProperty(String name, byte value); @Override JMSProducer setProperty(String name, double value); @Override JMSProducer setProperty(String name, float value); @Override JMSProducer setProperty(String name, int value); @Override JMSProducer setProperty(String name, long value); @Override JMSProducer setProperty(String name, Object value); @Override JMSProducer setProperty(String name, short value); @Override JMSProducer setProperty(String name, String value); @Override String getJMSCorrelationID(); @Override JMSProducer setJMSCorrelationID(String correlationId); @Override byte[] getJMSCorrelationIDAsBytes(); @Override JMSProducer setJMSCorrelationIDAsBytes(byte[] correlationIdBytes); @Override Destination getJMSReplyTo(); @Override JMSProducer setJMSReplyTo(Destination replyTo); @Override String getJMSType(); @Override JMSProducer setJMSType(String type); @Override CompletionListener getAsync(); @Override JMSProducer setAsync(CompletionListener completionListener); @Override long getDeliveryDelay(); @Override JMSProducer setDeliveryDelay(long deliveryDelay); @Override int getDeliveryMode(); @Override JMSProducer setDeliveryMode(int deliveryMode); @Override boolean getDisableMessageID(); @Override JMSProducer setDisableMessageID(boolean disableMessageId); @Override boolean getDisableMessageTimestamp(); @Override JMSProducer setDisableMessageTimestamp(boolean disableTimestamp); @Override int getPriority(); @Override JMSProducer setPriority(int priority); @Override long getTimeToLive(); @Override JMSProducer setTimeToLive(long timeToLive); MessageProducer getMessageProducer(); }### Answer: @Test public void testGetPropertyNames() { JMSProducer producer = context.createProducer(); producer.setProperty("Property_1", "1"); producer.setProperty("Property_2", "2"); producer.setProperty("Property_3", "3"); assertEquals(3, producer.getPropertyNames().size()); assertTrue(producer.getPropertyNames().contains("Property_1")); assertTrue(producer.getPropertyNames().contains("Property_2")); assertTrue(producer.getPropertyNames().contains("Property_3")); }
### 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: JmsPoolSession implements Session, TopicSession, QueueSession, XASession, AutoCloseable { @Override public String toString() { try { return getClass().getSimpleName() + " { " + safeGetSessionHolder() + " }"; } catch (JMSException e) { return getClass().getSimpleName() + " { " + null + " }"; } } JmsPoolSession(PooledSessionKey key, PooledSessionHolder sessionHolder, KeyedObjectPool<PooledSessionKey, PooledSessionHolder> sessionPool, boolean transactional); @Override void close(); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override Queue createQueue(String s); @Override Topic createTopic(String s); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable serializable); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String s); @Override void unsubscribe(String s); @Override int getAcknowledgeMode(); @Override boolean getTransacted(); @Override void recover(); @Override void commit(); @Override void rollback(); @Override XAResource getXAResource(); @Override Session getSession(); @Override MessageListener getMessageListener(); @Override void setMessageListener(MessageListener messageListener); @Override void run(); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override MessageConsumer createConsumer(Destination destination); @Override MessageConsumer createConsumer(Destination destination, String selector); @Override MessageConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override TopicSubscriber createDurableSubscriber(Topic topic, String selector); @Override TopicSubscriber createDurableSubscriber(Topic topic, String name, String selector, boolean noLocal); @Override TopicSubscriber createSubscriber(Topic topic); @Override TopicSubscriber createSubscriber(Topic topic, String selector, boolean local); @Override QueueReceiver createReceiver(Queue queue); @Override QueueReceiver createReceiver(Queue queue, String selector); @Override MessageConsumer createSharedConsumer(Topic topic, String sharedSubscriptionName); @Override MessageConsumer createSharedConsumer(Topic topic, String sharedSubscriptionName, String messageSelector); @Override MessageConsumer createDurableConsumer(Topic topic, String name); @Override MessageConsumer createDurableConsumer(Topic topic, String name, String messageSelector, boolean noLocal); @Override MessageConsumer createSharedDurableConsumer(Topic topic, String name); @Override MessageConsumer createSharedDurableConsumer(Topic topic, String name, String messageSelector); @Override MessageProducer createProducer(Destination destination); @Override QueueSender createSender(Queue queue); @Override TopicPublisher createPublisher(Topic topic); void addSessionEventListener(JmsPoolSessionEventListener listener); Session getInternalSession(); void setIsXa(boolean isXa); boolean isIgnoreClose(); void setIgnoreClose(boolean ignoreClose); @Override String toString(); }### Answer: @Test(timeout = 60000) public void testToString() throws Exception { JmsPoolConnection connection = (JmsPoolConnection) cf.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); assertNotNull(session.toString()); session.close(); assertNotNull(session.toString()); }
### Question: JmsPoolSession implements Session, TopicSession, QueueSession, XASession, AutoCloseable { public boolean isIgnoreClose() { return ignoreClose; } JmsPoolSession(PooledSessionKey key, PooledSessionHolder sessionHolder, KeyedObjectPool<PooledSessionKey, PooledSessionHolder> sessionPool, boolean transactional); @Override void close(); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override Queue createQueue(String s); @Override Topic createTopic(String s); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable serializable); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String s); @Override void unsubscribe(String s); @Override int getAcknowledgeMode(); @Override boolean getTransacted(); @Override void recover(); @Override void commit(); @Override void rollback(); @Override XAResource getXAResource(); @Override Session getSession(); @Override MessageListener getMessageListener(); @Override void setMessageListener(MessageListener messageListener); @Override void run(); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override MessageConsumer createConsumer(Destination destination); @Override MessageConsumer createConsumer(Destination destination, String selector); @Override MessageConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override TopicSubscriber createDurableSubscriber(Topic topic, String selector); @Override TopicSubscriber createDurableSubscriber(Topic topic, String name, String selector, boolean noLocal); @Override TopicSubscriber createSubscriber(Topic topic); @Override TopicSubscriber createSubscriber(Topic topic, String selector, boolean local); @Override QueueReceiver createReceiver(Queue queue); @Override QueueReceiver createReceiver(Queue queue, String selector); @Override MessageConsumer createSharedConsumer(Topic topic, String sharedSubscriptionName); @Override MessageConsumer createSharedConsumer(Topic topic, String sharedSubscriptionName, String messageSelector); @Override MessageConsumer createDurableConsumer(Topic topic, String name); @Override MessageConsumer createDurableConsumer(Topic topic, String name, String messageSelector, boolean noLocal); @Override MessageConsumer createSharedDurableConsumer(Topic topic, String name); @Override MessageConsumer createSharedDurableConsumer(Topic topic, String name, String messageSelector); @Override MessageProducer createProducer(Destination destination); @Override QueueSender createSender(Queue queue); @Override TopicPublisher createPublisher(Topic topic); void addSessionEventListener(JmsPoolSessionEventListener listener); Session getInternalSession(); void setIsXa(boolean isXa); boolean isIgnoreClose(); void setIgnoreClose(boolean ignoreClose); @Override String toString(); }### Answer: @Test(timeout = 60000) public void testIsIgnoreClose() throws Exception { JmsPoolConnection connection = (JmsPoolConnection) cf.createConnection(); JmsPoolSession session = (JmsPoolSession) connection.createSession(false, Session.AUTO_ACKNOWLEDGE); assertFalse(session.isIgnoreClose()); session.setIgnoreClose(true); assertTrue(session.isIgnoreClose()); }
### Question: JmsPoolSession implements Session, TopicSession, QueueSession, XASession, AutoCloseable { @Override public void run() { final PooledSessionHolder session; try { session = safeGetSessionHolder(); } catch (JMSException e) { throw JMSExceptionSupport.createRuntimeException(e); } if (session != null) { session.getSession().run(); } } JmsPoolSession(PooledSessionKey key, PooledSessionHolder sessionHolder, KeyedObjectPool<PooledSessionKey, PooledSessionHolder> sessionPool, boolean transactional); @Override void close(); @Override TemporaryQueue createTemporaryQueue(); @Override TemporaryTopic createTemporaryTopic(); @Override Queue createQueue(String s); @Override Topic createTopic(String s); @Override BytesMessage createBytesMessage(); @Override MapMessage createMapMessage(); @Override Message createMessage(); @Override ObjectMessage createObjectMessage(); @Override ObjectMessage createObjectMessage(Serializable serializable); @Override StreamMessage createStreamMessage(); @Override TextMessage createTextMessage(); @Override TextMessage createTextMessage(String s); @Override void unsubscribe(String s); @Override int getAcknowledgeMode(); @Override boolean getTransacted(); @Override void recover(); @Override void commit(); @Override void rollback(); @Override XAResource getXAResource(); @Override Session getSession(); @Override MessageListener getMessageListener(); @Override void setMessageListener(MessageListener messageListener); @Override void run(); @Override QueueBrowser createBrowser(Queue queue); @Override QueueBrowser createBrowser(Queue queue, String selector); @Override MessageConsumer createConsumer(Destination destination); @Override MessageConsumer createConsumer(Destination destination, String selector); @Override MessageConsumer createConsumer(Destination destination, String selector, boolean noLocal); @Override TopicSubscriber createDurableSubscriber(Topic topic, String selector); @Override TopicSubscriber createDurableSubscriber(Topic topic, String name, String selector, boolean noLocal); @Override TopicSubscriber createSubscriber(Topic topic); @Override TopicSubscriber createSubscriber(Topic topic, String selector, boolean local); @Override QueueReceiver createReceiver(Queue queue); @Override QueueReceiver createReceiver(Queue queue, String selector); @Override MessageConsumer createSharedConsumer(Topic topic, String sharedSubscriptionName); @Override MessageConsumer createSharedConsumer(Topic topic, String sharedSubscriptionName, String messageSelector); @Override MessageConsumer createDurableConsumer(Topic topic, String name); @Override MessageConsumer createDurableConsumer(Topic topic, String name, String messageSelector, boolean noLocal); @Override MessageConsumer createSharedDurableConsumer(Topic topic, String name); @Override MessageConsumer createSharedDurableConsumer(Topic topic, String name, String messageSelector); @Override MessageProducer createProducer(Destination destination); @Override QueueSender createSender(Queue queue); @Override TopicPublisher createPublisher(Topic topic); void addSessionEventListener(JmsPoolSessionEventListener listener); Session getInternalSession(); void setIsXa(boolean isXa); boolean isIgnoreClose(); void setIgnoreClose(boolean ignoreClose); @Override String toString(); }### Answer: @Test(timeout = 60000) public void testRun() throws Exception { JmsPoolConnection connection = (JmsPoolConnection) cf.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); try { session.run(); fail("Session should be unable to run outside EE."); } catch (JMSRuntimeException jmsre) {} session.close(); try { session.run(); fail("Session should be closed."); } catch (IllegalStateRuntimeException isre) {} }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.