import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@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);
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
/**
 * 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
    }
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
/**
 * 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());
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@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);
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
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());
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@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();
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
/**
 * 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
    }
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
/**
 * 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());
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
/**
 * 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());
    }
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@BeforeMethod
public void setUpMethod() throws Exception {
    // Make sure the provider provider that is registered is removed
    // before each run
    SyncFactory.unregisterProvider(stubProvider);
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@Test
public void test() throws SyncFactoryException {
    SyncFactory syncFactory = SyncFactory.getSyncFactory();
    assertTrue(syncFactory != null);
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@Test
public void test00() throws SyncFactoryException {
    SyncProvider p = SyncFactory.getInstance(propertyStubProvider);
    assertTrue(p instanceof PropertyStubProvider);
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@Test
public void test01() throws SyncFactoryException {
    SyncFactory.registerProvider(stubProvider);
    SyncProvider p = SyncFactory.getInstance(stubProvider);
    assertTrue(p instanceof StubSyncProvider);
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@Test(expectedExceptions = SyncFactoryException.class)
public void test03() throws SyncFactoryException {
    SyncProvider p = SyncFactory.getInstance(null);
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@Test(expectedExceptions = SyncFactoryException.class,enabled=true)
public void test04() throws SyncFactoryException {
    Logger l = SyncFactory.getLogger();
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@Test
public void test05() throws SyncFactoryException {
    SyncFactory.setLogger(alogger);
    Logger l = SyncFactory.getLogger();
    assertTrue(l.equals(alogger));
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@Test
public void test06() throws SyncFactoryException {
    SyncFactory.setLogger(alogger, Level.INFO);
    Logger l = SyncFactory.getLogger();
    assertTrue(l.equals(alogger));
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@Test(expectedExceptions = SyncFactoryException.class, enabled=true)
public void test08() throws Exception {
    SyncFactory.setJNDIContext(null);
}
 

import javax.sql.rowset.spi.SyncFactory; //导入依赖的package包/类
@Test(enabled=true)
public void test09() throws Exception {
    SyncFactory.setJNDIContext(ctx);
}