@Test public void test07() throws SyncFactoryException { // Validate that only the default providers and any specified via // a System property are available validateProviders(initialProviders); // Register a provider and make sure it is avaiable SyncFactory.registerProvider(stubProvider); validateProviders(allProviders); // Check that if a provider is unregistered, it does not show as // registered SyncFactory.unregisterProvider(stubProvider); validateProviders(initialProviders); }
/** * Test method for * {@link javax.sql.rowset.spi.SyncFactory#getInstance(java.lang.String)}. * * @throws SyncFactoryException */ public void test_getInstance_Ljava_lang_String() throws SyncFactoryException { Enumeration<SyncProvider> providers = SyncFactory .getRegisteredProviders(); SyncProvider expected = providers.nextElement(); String id = expected.getProviderID(); SyncProvider provider = SyncFactory.getInstance(id); assertEquals("getInstance error", expected.getVersion(), provider .getVersion()); provider = SyncFactory.getInstance("nonExist");// should return default assertNotNull(provider); try { provider = SyncFactory.getInstance(null); fail("should throw NullPointerException"); } catch (NullPointerException e) { // expected } }
/** * Test method for * {@link javax.sql.rowset.spi.SyncFactory#setLogger(java.util.logging.Logger, java.util.logging.Level)} * * @throws SyncFactoryException */ public void test_setLogger_Ljava_util_logging_LoggerLjava_util_logging_Level() throws SyncFactoryException { Logger logger = Logger.getAnonymousLogger(); Level level = Level.parse("WARNING"); SyncFactory.setLogger(logger, level); Logger actual = SyncFactory.getLogger(); assertEquals("set logger or get logger error", logger, actual); assertEquals("set logger error in set level", level, logger.getLevel()); try { SyncFactory.setLogger(null, level); fail("should throw NullPointerException"); } catch (NullPointerException e) { // expected } SyncFactory.setLogger(logger, null); assertNull(SyncFactory.getLogger().getLevel()); }
@Test public void test02() throws SyncFactoryException { SyncProvider p = SyncFactory.getInstance(""); assertTrue(p instanceof RIOptimisticProvider); // Attempt to get an invalid provider and get the default provider p = SyncFactory.getInstance("util.InvalidSyncProvider"); assertTrue(p instanceof RIOptimisticProvider); }
private void validateProviders(List<String> expectedProviders) throws SyncFactoryException { List<String> results = new ArrayList<>(); Enumeration<SyncProvider> providers = SyncFactory.getRegisteredProviders(); while (providers.hasMoreElements()) { SyncProvider p = providers.nextElement(); results.add(p.getProviderID()); } assertTrue(expectedProviders.containsAll(results) && results.size() == expectedProviders.size()); }
@Test(dataProvider = "rowSetType") public void commonCachedRowSetTest0003(CachedRowSet rs) throws SQLException { // Register a provider and make sure it is avaiable SyncFactory.registerProvider(stubProvider); rs.setSyncProvider(stubProvider); SyncProvider sp = rs.getSyncProvider(); assertTrue(sp instanceof StubSyncProvider); SyncFactory.unregisterProvider(stubProvider); rs.close(); }
/** * Test method for * {@link javax.sql.rowset.spi.SyncFactory#setLogger(java.util.logging.Logger)} * {@link javax.sql.rowset.spi.SyncFactory#getLogger()} . * * @throws SyncFactoryException */ public void test_setLogger_Ljava_util_logging_Logger() throws SyncFactoryException { Logger logger = Logger.getAnonymousLogger(); SyncFactory.setLogger(logger); assertEquals(logger, SyncFactory.getLogger()); SyncFactory.setLogger(null); try { SyncFactory.getLogger(); fail("should throw SyncFactoryException"); } catch (SyncFactoryException e) { // expected } }
/** * Test method for * {@link javax.sql.rowset.spi.SyncFactory#setJNDIContext(javax.naming.Context)} * * @throws NamingException * @throws SyncFactoryException */ public void test_setJNDIContext_Ljavax_naming_Context() throws NamingException, SyncFactoryException { try { SyncFactory.setJNDIContext(null); fail("Should throw SyncFactoryException"); } catch (SyncFactoryException e) { // expected } SyncFactory.setJNDIContext(new InitialContext()); }
/** * Test for SyncFactory.getRegisteredProviders(). Regression for * HARMONY-6345. * * @throws SyncFactoryException */ public void testGetRegisteredProviders() throws SyncFactoryException { Enumeration<SyncProvider> providers = SyncFactory .getRegisteredProviders(); while (providers.hasMoreElements()) { SyncFactory.getInstance(providers.nextElement().getProviderID()); } }
@BeforeMethod public void setUpMethod() throws Exception { // Make sure the provider provider that is registered is removed // before each run SyncFactory.unregisterProvider(stubProvider); }
@Test public void test() throws SyncFactoryException { SyncFactory syncFactory = SyncFactory.getSyncFactory(); assertTrue(syncFactory != null); }
@Test public void test00() throws SyncFactoryException { SyncProvider p = SyncFactory.getInstance(propertyStubProvider); assertTrue(p instanceof PropertyStubProvider); }
@Test public void test01() throws SyncFactoryException { SyncFactory.registerProvider(stubProvider); SyncProvider p = SyncFactory.getInstance(stubProvider); assertTrue(p instanceof StubSyncProvider); }
@Test(expectedExceptions = SyncFactoryException.class) public void test03() throws SyncFactoryException { SyncProvider p = SyncFactory.getInstance(null); }
@Test(expectedExceptions = SyncFactoryException.class,enabled=true) public void test04() throws SyncFactoryException { Logger l = SyncFactory.getLogger(); }
@Test public void test05() throws SyncFactoryException { SyncFactory.setLogger(alogger); Logger l = SyncFactory.getLogger(); assertTrue(l.equals(alogger)); }
@Test public void test06() throws SyncFactoryException { SyncFactory.setLogger(alogger, Level.INFO); Logger l = SyncFactory.getLogger(); assertTrue(l.equals(alogger)); }
@Test(expectedExceptions = SyncFactoryException.class, enabled=true) public void test08() throws Exception { SyncFactory.setJNDIContext(null); }
@Test(enabled=true) public void test09() throws Exception { SyncFactory.setJNDIContext(ctx); }
