@Override
  @SuppressWarnings({"rawtypes", "unchecked"})
  public Family createMappedForm(PersistentEntity entity) {
    ClassPropertyFetcher cpf = ClassPropertyFetcher.forClass(entity.getJavaClass());
    final Closure value = cpf.getStaticPropertyValue(GormProperties.MAPPING, Closure.class);
    if (value == null) {
      return new Region();
    }

    final Region family = new Region();
    AttributesFactory factory =
        new AttributesFactory() {
          @SuppressWarnings("unused")
          public void setRegion(String name) {
            family.setRegion(name);
          }
        };
    factory.setDataPolicy(defaultDataPolicy);

    MappingConfigurationBuilder builder = new MappingConfigurationBuilder(factory, KeyValue.class);
    builder.evaluate(value);
    entityToPropertyMap.put(entity, builder.getProperties());
    final RegionAttributes regionAttributes = factory.create();
    family.setRegionAttributes(regionAttributes);
    family.setCacheListeners(regionAttributes.getCacheListeners());
    family.setDataPolicy(regionAttributes.getDataPolicy());
    family.setCacheLoader(regionAttributes.getCacheLoader());
    family.setCacheWriter(regionAttributes.getCacheWriter());

    builder = new MappingConfigurationBuilder(family, KeyValue.class);
    builder.evaluate(value);
    return family;
  }
 /** function to create client cache * */
 public static void createClientCache1(String host, Integer port1) throws Exception {
   PORT1 = port1.intValue();
   Properties props = new Properties();
   props.setProperty("mcast-port", "0");
   props.setProperty("locators", "");
   new PutAllDUnitTest("temp").createCache(props);
   props.setProperty("retryAttempts", "2");
   props.setProperty("endpoints", "ep1=" + host + ":" + PORT1);
   props.setProperty("redundancyLevel", "-1");
   props.setProperty("establishCallbackConnection", "true");
   props.setProperty("LBPolicy", "Sticky");
   props.setProperty("readTimeout", "2000");
   props.setProperty("socketBufferSize", "1000");
   props.setProperty("retryInterval", "250");
   props.setProperty("connectionsPerServer", "2");
   AttributesFactory factory = new AttributesFactory();
   factory.setScope(Scope.DISTRIBUTED_ACK);
   PoolImpl p =
       (PoolImpl)
           ClientServerTestCase.configureConnectionPool(
               factory, host, PORT1, -1, true, -1, 2, null);
   CacheListener clientListener = new HAEventIdPropagationListenerForClient1();
   factory.setCacheListener(clientListener);
   RegionAttributes attrs = factory.create();
   cache.createRegion(REGION_NAME, attrs);
   Region region = cache.getRegion(Region.SEPARATOR + REGION_NAME);
   assertNotNull(region);
   region.registerInterest("ALL_KEYS", InterestResultPolicy.NONE);
   pool = p;
 }
  @Test
  public void testAllIndexesOnCommitForPut() throws Exception {
    // create region
    AttributesFactory af = new AttributesFactory();
    af.setDataPolicy(DataPolicy.REPLICATE);
    Region region = cache.createRegion("sample", af.create());

    // put data
    for (int i = 0; i < 10; i++) {
      region.put(i, new Portfolio(i));
    }

    String[] queries = {
      "select * from /sample where ID = 5",
      "select ID from /sample where ID < 5",
      "select ID from /sample where ID > 5",
      "select ID from /sample where ID != 5",
      "select status from /sample where status = 'active'",
      "select status from /sample where status > 'active'",
      "select status from /sample where status < 'active'",
      "select status from /sample where status != 'active'",
      "select pos.secId from /sample p, p.positions.values pos where pos.secId = 'IBM'",
      "select pos.secId from /sample p, p.positions.values pos where pos.secId < 'VMW'",
      "select pos.secId from /sample p, p.positions.values pos where pos.secId > 'IBM'",
      "select pos.secId from /sample p, p.positions.values pos where pos.secId != 'IBM'"
    };

    SelectResults[][] sr = new SelectResults[queries.length][2];

    // execute queries without indexes
    for (int i = 0; i < queries.length; i++) {
      sr[i][0] = (SelectResults) qs.newQuery(queries[i]).execute();
    }

    // create indexes
    qs.createKeyIndex("IDIndex", "ID", "/sample");
    qs.createIndex("statusIndex", "status", "/sample");
    qs.createIndex("secIdIndex", "pos.secId", "/sample p, p.positions.values pos");

    // begin transaction
    Context ctx = cache.getJNDIContext();
    UserTransaction utx = (UserTransaction) ctx.lookup("java:/UserTransaction");
    utx.begin();

    // update data
    for (int i = 0; i < 10; i++) {
      region.put(i, new Portfolio(i));
    }

    // execute queries with indexes during transaction
    for (int i = 0; i < queries.length; i++) {
      sr[i][1] = (SelectResults) qs.newQuery(queries[i]).execute();
    }

    // complete transaction
    utx.commit();

    // verify results
    com.gemstone.gemfire.cache.query.CacheUtils.compareResultsOfWithAndWithoutIndex(sr);
  }
 /** Helper Methods */
 private void createLocalRegion() throws ParseException {
   Cache cache = CacheUtils.getCache();
   AttributesFactory attributesFactory = new AttributesFactory();
   attributesFactory.setDataPolicy(DataPolicy.NORMAL);
   RegionAttributes regionAttributes = attributesFactory.create();
   Region region = cache.createRegion(regionName, regionAttributes);
 }
  @Test
  public void testFailedIndexUpdateOnCommitForPut() throws Exception {
    Person.THROW_ON_INDEX = true;
    AttributesFactory af = new AttributesFactory();
    af.setDataPolicy(DataPolicy.REPLICATE);
    SimpleListener sl = new SimpleListener();
    af.setCacheListener(sl);
    Region region = cache.createRegion("sample", af.create());
    qs.createIndex("foo", IndexType.FUNCTIONAL, "index", "/sample");
    Context ctx = cache.getJNDIContext();

    Integer x = new Integer(0);
    region.getCache().getCacheTransactionManager().begin();
    region.create(x, new Person("xyz", 45));
    try {
      region.getCache().getCacheTransactionManager().commit();
      fail("commit should have thrown an exception because the index maintenance threw");
    } catch (com.gemstone.gemfire.cache.query.IndexMaintenanceException ie) {
      // this is the desired case
    }
    Person p = (Person) region.get(x);
    assertEquals("object shouldn't have made it into region", null, p);
    assertEquals(0, sl.creates);
    assertEquals(0, sl.updates);
  }
 public void DISABLED_testTxWithCloning() {
   AttributesFactory af = new AttributesFactory();
   af.setDataPolicy(DataPolicy.REPLICATE);
   af.setScope(Scope.DISTRIBUTED_ACK);
   af.setCloningEnabled(true);
   basicTest(af.create());
 }
  public static void createClientCache(String host, Integer port1, Integer port2) throws Exception {
    PORT1 = port1.intValue();
    PORT2 = port2.intValue();
    Properties props = new Properties();
    props.setProperty(DistributionConfig.MCAST_PORT_NAME, "0");
    props.setProperty(DistributionConfig.LOCATORS_NAME, "");
    new DestroyEntryPropagationDUnitTest("temp").createCache(props);
    CacheServerTestUtil.disableShufflingOfEndpoints();
    Pool p;
    try {
      p =
          PoolManager.createFactory()
              .addServer(host, PORT1)
              .addServer(host, PORT2)
              .setSubscriptionEnabled(true)
              .setSubscriptionRedundancy(-1)
              .setReadTimeout(2000)
              .setSocketBufferSize(1000)
              .setMinConnections(4)
              // .setRetryAttempts(2)
              // .setRetryInterval(250)
              .create("EntryPropagationDUnitTestPool");
    } finally {
      CacheServerTestUtil.enableShufflingOfEndpoints();
    }

    AttributesFactory factory = new AttributesFactory();
    factory.setScope(Scope.DISTRIBUTED_ACK);
    factory.setPoolName(p.getName());
    factory.setCacheListener(new CertifiableTestCacheListener(getLogWriter()));
    RegionAttributes attrs = factory.create();
    cache.createRegion(REGION_NAME, attrs);
  }
 private RegionAttributes createRegionAttributes(boolean isConcurrencyChecksEnabled) {
   AttributesFactory factory = new AttributesFactory();
   factory.setScope(Scope.DISTRIBUTED_ACK);
   factory.setDataPolicy(DataPolicy.REPLICATE);
   factory.setConcurrencyChecksEnabled(isConcurrencyChecksEnabled); //
   RegionAttributes ra = factory.create();
   return ra;
 }
 /**
  * create a client with 2 regions sharing a common writer
  *
  * @throws Exception
  */
 public static void createRegion() throws Exception {
   HARegionDUnitTest test = new HARegionDUnitTest(REGION_NAME);
   cache = test.createCache();
   AttributesFactory factory = new AttributesFactory();
   factory.setScope(Scope.DISTRIBUTED_ACK);
   factory.setDataPolicy(DataPolicy.REPLICATE);
   HARegion.getInstance(REGION_NAME, (GemFireCacheImpl) cache, null, factory.create());
 }
 @Override
 public Region createRegion(String regionName, Class valueConstraint) {
   PartitionAttributesFactory paf = new PartitionAttributesFactory();
   AttributesFactory af = new AttributesFactory();
   af.setPartitionAttributes(paf.create());
   af.setValueConstraint(valueConstraint);
   Region r1 = CacheUtils.createRegion(regionName, af.create(), false);
   return r1;
 }
 @Before
 public void setUp() throws Exception {
   tblName = CacheUtils.init("CacheTest");
   cache = CacheUtils.getCache();
   AttributesFactory attributesFactory = new AttributesFactory();
   attributesFactory.setValueConstraint(Portfolio.class);
   RegionAttributes regionAttributes = attributesFactory.create();
   currRegion = cache.createRegion("portfolios", regionAttributes);
   qs = CacheUtils.getQueryService();
 }
 @SuppressWarnings({"unchecked", "deprecation", "rawtypes"})
 void createRegion(String name, boolean accessor, int redundantCopies, CacheWriter<?, ?> cw) {
   AttributesFactory af = new AttributesFactory();
   af.setPartitionAttributes(
       new PartitionAttributesFactory()
           .setLocalMaxMemory(accessor ? 0 : 12)
           .setRedundantCopies(redundantCopies)
           .create());
   af.setCacheWriter(cw);
   getCache().createRegion(name, af.create());
 }
  protected AttributesFactory getServerCacheAttributesFactory(boolean enableStorage) {
    AttributesFactory factory = new AttributesFactory();
    PartitionAttributesFactory paf = new PartitionAttributesFactory();
    factory.setDataPolicy(DataPolicy.PARTITION);
    paf.setRedundantCopies(0).setTotalNumBuckets(1);
    if (!enableStorage) {
      paf.setLocalMaxMemory(0);
    }

    factory.setPartitionAttributes(paf.create());
    return factory;
  }
 /**
  * Tests the where clause formed with CompiledComparison nesting with CompiledIN
  *
  * @throws Exception
  */
 @Test
 public void testBug40333_InLocalRegion_2() throws Exception {
   CacheUtils.startCache();
   final Cache cache = CacheUtils.getCache();
   AttributesFactory attributesFactory = new AttributesFactory();
   RegionAttributes ra = attributesFactory.create();
   final Region region = cache.createRegion("new_pos", ra);
   String queryStr =
       " select distinct r.name, pVal, r.\"type\"  "
           + " from /new_pos r , r.positions.values pVal where "
           + " ( r.name IN Set('name_11' , 'name_12') OR false ) AND pVal.mktValue = 1.00";
   this.bug40333Simulation(region, queryStr);
 }
 public static void createCacheClient(Pool poolAttr, String regionName1, String regionName2)
     throws Exception {
   new CacheServerTestUtil("temp").createCache(getClientProperties());
   PoolFactoryImpl pf = (PoolFactoryImpl) PoolManager.createFactory();
   pf.init(poolAttr);
   PoolImpl p = (PoolImpl) pf.create("CacheServerTestUtil");
   AttributesFactory factory = new AttributesFactory();
   factory.setScope(Scope.LOCAL);
   factory.setPoolName(p.getName());
   RegionAttributes attrs = factory.create();
   cache.createRegion(regionName1, attrs);
   cache.createRegion(regionName2, attrs);
   pool = p;
 }
 /**
  * Set a random DiskStore for the region defined with regionConfigName if it is persistent or has
  * eviction with overflow to disk.
  *
  * @param regionConfigName A hydra region config name. return factory The attributes factory for
  *     the regionConfigName with possibly a DiskStore.
  */
 public static AttributesFactory setDiskStoreIfNeeded(String regionConfigName) {
   AttributesFactory factory = RegionHelper.getAttributesFactory(regionConfigName);
   RegionDescription desc = RegionHelper.getRegionDescription(regionConfigName);
   EvictionAttributes evAttr = desc.getEvictionAttributes();
   if ((desc.getDataPolicy().withPersistence())
       || ((evAttr != null) && (evAttr.getAction().isOverflowToDisk()))) {
     List diskStoreNames = TestConfig.tab().vecAt(DiskStorePrms.names);
     factory.setDiskStoreName(
         (String)
             (diskStoreNames.get(
                 TestConfig.tab().getRandGen().nextInt(1, diskStoreNames.size() - 1))));
   }
   return factory;
 }
 @SuppressWarnings({"rawtypes", "unchecked"})
 @Override
 protected RegionAttributes getRegionAttributes() {
   Compressor compressor = null;
   try {
     compressor = SnappyCompressor.getDefaultInstance();
   } catch (Throwable t) {
     // Not a supported OS
     return super.getRegionAttributes();
   }
   RegionAttributes attrs = super.getRegionAttributes();
   AttributesFactory factory = new AttributesFactory(attrs);
   factory.setCompressor(compressor);
   return factory.create();
 }
  protected void setUp() throws Exception {
    CacheUtils.startCache();
    cache = CacheUtils.getCache();
    AttributesFactory attributesFactory = new AttributesFactory();
    //    attributesFactory.setValueConstraint(Portfolio.class);
    RegionAttributes regionAttributes = attributesFactory.create();

    region = cache.createRegion("pos", regionAttributes);
    region.put("0", new Portfolio(0));
    region.put("1", new Portfolio(1));
    region.put("2", new Portfolio(2));
    region.put("3", new Portfolio(3));

    qs = cache.getQueryService();
  }
  /**
   * Tests that we are in {@link GemFireHealth#OKAY_HEALTH okay} health if the hit ratio dips below
   * the threshold.
   */
  public void testCheckHitRatio() throws CacheException {
    Cache cache = CacheFactory.create(this.system);
    //    CachePerfStats stats = ((GemFireCache) cache).getCachePerfStats();

    AttributesFactory factory = new AttributesFactory();
    factory.setScope(Scope.LOCAL);
    factory.setCacheLoader(
        new CacheLoader() {
          public Object load(LoaderHelper helper) throws CacheLoaderException {

            return "Loaded";
          }

          public void close() {}
        });

    RegionAttributes attrs = factory.create();
    Region region = cache.createRegion(this.getName(), attrs);

    GemFireHealthConfig config = new GemFireHealthConfigImpl(null);
    config.setMinHitRatio(0.5);

    CacheHealthEvaluator eval =
        new CacheHealthEvaluator(config, this.system.getDistributionManager());
    List status = new ArrayList();
    eval.evaluate(status);
    assertEquals(0, status.size());

    region.get("One");
    region.get("One");
    region.get("One");

    status = new ArrayList();
    eval.evaluate(status);
    assertEquals(0, status.size());

    for (int i = 0; i < 50; i++) {
      region.get("Miss " + i);
    }

    status = new ArrayList();
    eval.evaluate(status);

    AbstractHealthEvaluator.HealthStatus ill = (AbstractHealthEvaluator.HealthStatus) status.get(0);
    assertEquals(GemFireHealth.OKAY_HEALTH, ill.getHealthCode());
    String s = "The hit ratio of this Cache";
    assertTrue(ill.getDiagnosis().indexOf(s) != -1);
  }
  public static Integer createServerCache() throws Exception {
    new DestroyEntryPropagationDUnitTest("temp").createCache(new Properties());
    AttributesFactory factory = new AttributesFactory();
    factory.setScope(Scope.DISTRIBUTED_ACK);
    factory.setDataPolicy(DataPolicy.REPLICATE);
    factory.setCacheListener(new CertifiableTestCacheListener(getLogWriter()));
    RegionAttributes attrs = factory.create();
    cache.createRegion(REGION_NAME, attrs);

    BridgeServer server = cache.addBridgeServer();
    int port = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
    server.setPort(port);
    server.setNotifyBySubscription(true);
    server.start();
    return new Integer(server.getPort());
  }
 /**
  * Commented the test as it is for some reason causing OOM when run in the suite. It is due to
  * presence of PR Tests the where clause formed with CompiledComparison nesting with CompiledIN
  *
  * @throws Exception
  */
 public void _testBug40333_InPartitionedRegion_2() throws Exception {
   CacheUtils.startCache();
   final Cache cache = CacheUtils.getCache();
   AttributesFactory attributesFactory = new AttributesFactory();
   PartitionAttributesFactory paf = new PartitionAttributesFactory();
   paf.setTotalNumBuckets(10);
   PartitionAttributes pa = paf.create();
   attributesFactory.setPartitionAttributes(pa);
   RegionAttributes ra = attributesFactory.create();
   final Region region = cache.createRegion("new_pos", ra);
   String queryStr =
       " select distinct r.name, pVal, r.\"type\"  "
           + " from /new_pos r , r.positions.values pVal where "
           + " ( r.name IN Set('name_11' , 'name_12') OR false ) AND pVal.mktValue < 1.00";
   this.bug40333Simulation(region, queryStr);
 }
 protected RegionAttributes getDiskRegionAttributes() {
   AttributesFactory factory = new AttributesFactory(getRegionAttributes());
   File[] diskDirs = new File[1];
   diskDirs[0] = new File("diskRegionDirs/" + OSProcess.getId());
   diskDirs[0].mkdirs();
   factory.setDiskStoreName(
       getCache()
           .createDiskStoreFactory()
           .setDiskDirs(diskDirs)
           .setTimeInterval(1000)
           .setQueueSize(0)
           .create("TXRestrictionsDUnitTest")
           .getName());
   factory.setDataPolicy(DataPolicy.PERSISTENT_REPLICATE);
   return factory.create();
 }
 /** create the server * */
 public static Integer createServerCache() throws Exception {
   new PutAllDUnitTest("temp").createCache(new Properties());
   AttributesFactory factory = new AttributesFactory();
   factory.setScope(Scope.DISTRIBUTED_ACK);
   factory.setDataPolicy(DataPolicy.REPLICATE);
   CacheListener clientListener = new HAEventIdPropagationListenerForClient1();
   factory.setCacheListener(clientListener);
   RegionAttributes attrs = factory.create();
   cache.createRegion(REGION_NAME, attrs);
   server = (CacheServerImpl) cache.addCacheServer();
   assertNotNull(server);
   int port = AvailablePort.getRandomAvailablePort(AvailablePort.SOCKET);
   server.setPort(port);
   server.setNotifyBySubscription(true);
   server.start();
   return new Integer(server.getPort());
 }
 @SuppressWarnings({"rawtypes", "unchecked"})
 @Override
 protected RegionAttributes getRegionAttributes(String type) {
   Compressor compressor = null;
   try {
     compressor = SnappyCompressor.getDefaultInstance();
   } catch (Throwable t) {
     // Not a supported OS
     return super.getRegionAttributes(type);
   }
   RegionAttributes ra = super.getRegionAttributes(type);
   AttributesFactory factory = new AttributesFactory(ra);
   if (!ra.getDataPolicy().isEmpty()) {
     factory.setCompressor(compressor);
   }
   return factory.create();
 }
 public static void createCacheClient(
     Pool poolAttr, String regionName, Properties dsProperties, Boolean addControlListener)
     throws Exception {
   new CacheServerTestUtil("temp").createCache(dsProperties);
   PoolFactoryImpl pf = (PoolFactoryImpl) PoolManager.createFactory();
   pf.init(poolAttr);
   PoolImpl p = (PoolImpl) pf.create("CacheServerTestUtil");
   AttributesFactory factory = new AttributesFactory();
   factory.setScope(Scope.LOCAL);
   factory.setPoolName(p.getName());
   if (addControlListener.booleanValue()) {
     factory.addCacheListener(new ControlListener());
   }
   RegionAttributes attrs = factory.create();
   cache.createRegion(regionName, attrs);
   pool = p;
 }
  @Test
  public void testBug40441() throws Exception {
    CacheUtils.startCache();
    final Cache cache = CacheUtils.getCache();
    AttributesFactory attributesFactory = new AttributesFactory();
    RegionAttributes ra = attributesFactory.create();
    final Region region = cache.createRegion("new_pos", ra);
    String queryStr1 =
        " select distinct r.name, pVal, r.\"type\"  "
            + " from /new_pos r , r.positions.values pVal where "
            + " ( r.undefinedTestField.toString = UNDEFINED  OR false ) "; // AND pVal.mktValue =
                                                                           // 1.00";
    String queryStr2 =
        " select distinct r.name, pVal, r.\"type\"  "
            + " from /new_pos r , r.positions.values pVal where "
            + " ( r.undefinedTestField.toString = UNDEFINED  AND true ) AND pVal.mktValue = 1.00";
    final QueryService qs = CacheUtils.getQueryService();
    for (int i = 1; i < 100; ++i) {
      NewPortfolio pf = new NewPortfolio("name" + i, i);
      region.put("name" + i, pf);
    }

    Index indx1 =
        qs.createIndex(
            "MarketValues",
            IndexType.FUNCTIONAL,
            "itr2.mktValue",
            "/new_pos itr1, itr1.positions.values itr2");
    Index indx2 = qs.createIndex("Name", IndexType.FUNCTIONAL, "itr1.name", "/new_pos itr1");
    Index indx3 = qs.createIndex("nameIndex", IndexType.PRIMARY_KEY, "name", "/new_pos");
    Index indx4 = qs.createIndex("idIndex", IndexType.FUNCTIONAL, "id", "/new_pos");
    Index indx5 = qs.createIndex("statusIndex", IndexType.FUNCTIONAL, "status", "/new_pos");
    Index indx6 =
        qs.createIndex(
            "undefinedFieldIndex", IndexType.FUNCTIONAL, "undefinedTestField.toString", "/new_pos");
    final Query q1 = qs.newQuery(queryStr1);
    final Query q2 = qs.newQuery(queryStr2);
    try {
      SelectResults sr1 = (SelectResults) q1.execute();
      SelectResults sr2 = (SelectResults) q2.execute();
    } catch (Throwable e) {
      e.printStackTrace();
      fail("Test failed due to = " + e.toString());
    }
  }
  /**
   * Tests that a local writer receives a modified version of the callback argument on an update.
   */
  public void testLocalUpdateModifiedCallbackArgument() throws CacheException {

    final String name = this.getUniqueName();
    final Object key = "KEY";
    final Object value = "VALUE";
    final Object one = "ONE";
    final Object two = "TWO";

    TestCacheLoader loader =
        new TestCacheLoader() {
          public Object load2(LoaderHelper helper) throws CacheLoaderException {

            Object[] array = (Object[]) helper.getArgument();
            assertEquals(one, array[0]);
            array[0] = two;

            return value;
          }
        };

    TestCacheWriter writer =
        new TestCacheWriter() {
          public void beforeCreate2(EntryEvent event) throws CacheWriterException {}

          public void beforeUpdate2(EntryEvent event) throws CacheWriterException {

            Object[] array = (Object[]) event.getCallbackArgument();
            assertEquals(two, array[0]);
          }
        };

    AttributesFactory factory = new AttributesFactory(getRegionAttributes());
    factory.setCacheLoader(loader);
    factory.setCacheWriter(writer);
    Region region = createRegion(name, factory.create());

    region.create(key, null);
    assertFalse(loader.wasInvoked());
    assertTrue(writer.wasInvoked());

    Object[] array = new Object[] {one};
    assertEquals(value, region.get(key, array));
    assertTrue(loader.wasInvoked());
    assertTrue(writer.wasInvoked());
  }
 // @Test
 public void _testFailedIndexUpdateOnJTACommitForPut() throws Exception {
   Person.THROW_ON_INDEX = true;
   AttributesFactory af = new AttributesFactory();
   af.setDataPolicy(DataPolicy.REPLICATE);
   Region region = cache.createRegion("sample", af.create());
   qs.createIndex("foo", IndexType.FUNCTIONAL, "index", "/sample");
   Context ctx = cache.getJNDIContext();
   UserTransaction utx = (UserTransaction) ctx.lookup("java:/UserTransaction");
   Integer x = new Integer(0);
   utx.begin();
   region.create(x, new Person("xyz", 45));
   try {
     utx.commit();
     fail("Commit should have thrown an exception because the index update threw");
   } catch (Exception e) {
     // this is desired
   }
 }
  public static void createPool(PoolAttributes poolAttr) throws Exception {
    Properties props = new Properties();
    props.setProperty(DistributionConfig.MCAST_PORT_NAME, "0");
    props.setProperty(DistributionConfig.LOCATORS_NAME, "");

    DistributedSystem ds = new CacheServerTestUtil("tmp").getSystem(props);
    ;

    PoolFactoryImpl pf = (PoolFactoryImpl) PoolManager.createFactory();
    pf.init(poolAttr);
    PoolImpl p = (PoolImpl) pf.create("CacheServerTestUtil");
    AttributesFactory factory = new AttributesFactory();
    factory.setScope(Scope.LOCAL);
    factory.setPoolName(p.getName());

    RegionAttributes attrs = factory.create();
    pool = p;
  }
 /** Initializes proxy object and creates region for client */
 private void createProxyAndRegionForClient() {
   try {
     // props.setProperty("retryAttempts", "5");
     PoolFactory pf = PoolManager.createFactory();
     proxy =
         (PoolImpl)
             pf.addServer("localhost", PORT)
                 .setThreadLocalConnections(true)
                 .setReadTimeout(10000)
                 .setPingInterval(10000)
                 .setMinConnections(0)
                 .create("junitPool");
     AttributesFactory factory = new AttributesFactory();
     factory.setScope(Scope.DISTRIBUTED_ACK);
     cache.createVMRegion(regionName, factory.createRegionAttributes());
   } catch (Exception ex) {
     ex.printStackTrace();
     fail("Failed to initialize client");
   }
 }