@Test
  public void get() {
    String key = getKey(getUser("imaPigg"));

    assertThat(usersTemplate.get(key)).isEqualTo(users.get(key));
    assertNullEquals(users.get("mrT"), usersTemplate.get("mrT"));
  }
 public static void assertGotAllValues() {
   Region region = cache.getRegion(Region.SEPARATOR + REGION_NAME);
   assertNotNull(region);
   assertTrue(region.get(PUTALL_KEY1).equals(PUTALL_VALUE1));
   assertTrue(region.get(PUTALL_KEY2).equals(PUTALL_VALUE2));
   assertTrue(region.get(PUTALL_KEY3).equals(PUTALL_VALUE3));
   assertTrue(region.get(PUTALL_KEY4).equals(PUTALL_VALUE4));
   assertTrue(region.get(PUTALL_KEY5).equals(PUTALL_VALUE5));
 }
  @Test
  public void replaceOldValueWithNewValue() {
    User jackHandy = getUser("jackHandy");
    User imaPigg = getUser("imaPigg");

    assertThat(users.containsValue(jackHandy)).isTrue();
    assertThat(usersTemplate.replace(getKey(jackHandy), null, imaPigg)).isFalse();
    assertThat(users.containsValue(jackHandy)).isTrue();
    assertThat(users.get(getKey(jackHandy))).isEqualTo(jackHandy);
    assertThat(usersTemplate.replace(getKey(jackHandy), jackHandy, imaPigg)).isTrue();
    assertThat(users.containsValue(jackHandy)).isFalse();
    assertThat(users.get(getKey(jackHandy))).isEqualTo(imaPigg);
  }
  @Test
  public void replace() {
    User randyHandy = users.get(getKey(getUser("randyHandy")));
    User lukeFluke = newUser("lukeFluke");
    User chrisGriffon = newUser("chrisGriffon");

    assertThat(randyHandy).isNotNull();
    assertThat(usersTemplate.replace(getKey(randyHandy), lukeFluke)).isEqualTo(randyHandy);
    assertThat(users.get(getKey(randyHandy))).isEqualTo(lukeFluke);
    assertThat(users.containsValue(randyHandy)).isFalse();
    assertThat(users.containsValue(chrisGriffon)).isFalse();
    assertThat(usersTemplate.replace(getKey(chrisGriffon), chrisGriffon)).isNull();
    assertThat(users.containsValue(chrisGriffon)).isFalse();
  }
  public static void verifyDispatchedMessagesRemoved() {
    try {
      Region region = hrq.getRegion();
      if (region.get(new Long(0)) != null) {
        fail("Expected message to have been deleted but it is not deleted");
      }

      if (region.get(new Long(1)) == null) {
        fail("Expected message not to have been deleted but it is deleted");
      }
    } catch (Exception e) {
      fail("test failed due to an exception :  " + e);
    }
  }
  /**
   * 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);
  }
  @Test
  public void put() {
    User peterGriffon = newUser("peterGriffon");

    assertThat(usersTemplate.put(getKey(peterGriffon), peterGriffon)).isNull();
    assertThat(users.get(getKey(peterGriffon))).isEqualTo(peterGriffon);
  }
  private ByteBuffer processAsciiCommand(ByteBuffer buffer, Cache cache) {
    CharBuffer flb = getFirstLineBuffer();
    getAsciiDecoder().reset();
    getAsciiDecoder().decode(buffer, flb, false);
    flb.flip();
    String firstLine = getFirstLine();
    String[] firstLineElements = firstLine.split(" ");

    assert "decr".equals(firstLineElements[0]);
    String key = firstLineElements[1];
    String decrByStr = stripNewline(firstLineElements[2]);
    Long decrBy = Long.parseLong(decrByStr);
    boolean noReply = firstLineElements.length > 3;

    Region<Object, ValueWrapper> r = getMemcachedRegion(cache);
    String reply = Reply.NOT_FOUND.toString();
    ByteBuffer newVal = ByteBuffer.allocate(8);
    while (true) {
      ValueWrapper oldValWrapper = r.get(key);
      if (oldValWrapper == null) {
        break;
      }
      newVal.clear();
      byte[] oldVal = oldValWrapper.getValue();
      long oldLong = getLongFromByteArray(oldVal);
      long newLong = oldLong - decrBy;
      newVal.putLong(newLong);
      ValueWrapper newValWrapper = ValueWrapper.getWrappedValue(newVal.array(), 0 /*flags*/);
      if (r.replace(key, oldValWrapper, newValWrapper)) {
        reply = newLong + "\r\n";
        break;
      }
    }
    return noReply ? null : asciiCharset.encode(reply);
  }
  @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);
  }
 /**
  * Update an existing key in region REGION_NAME. The keys to update are specified in keyIntervals.
  *
  * @return true if all keys to be updated have been completed.
  */
 protected boolean updateExistingKey() {
   long nextKey =
       CQUtilBB.getBB().getSharedCounters().incrementAndRead(CQUtilBB.LASTKEY_UPDATE_EXISTING_KEY);
   if (!keyIntervals.keyInRange(KeyIntervals.UPDATE_EXISTING_KEY, nextKey)) {
     Log.getLogWriter().info("All existing keys updated; returning from updateExistingKey");
     return true;
   }
   Object key = NameFactory.getObjectNameForCounter(nextKey);
   QueryObject existingValue = (QueryObject) aRegion.get(key);
   if (existingValue == null)
     throw new TestException("Get of key " + key + " returned unexpected " + existingValue);
   QueryObject newValue = existingValue.modifyWithNewInstance(QueryObject.NEGATE, 0, true);
   newValue.extra = key; // encode the key in the object for later validation
   if (existingValue.aPrimitiveLong < 0)
     throw new TestException(
         "Trying to update a key which was already updated: " + existingValue.toStringFull());
   Log.getLogWriter()
       .info("Updating existing key " + key + " with value " + TestHelper.toString(newValue));
   aRegion.put(key, newValue);
   Log.getLogWriter()
       .info(
           "Done updating existing key "
               + key
               + " with value "
               + TestHelper.toString(newValue)
               + ", num remaining: "
               + (keyIntervals.getLastKey(KeyIntervals.UPDATE_EXISTING_KEY) - nextKey));
   return (nextKey >= keyIntervals.getLastKey(KeyIntervals.UPDATE_EXISTING_KEY));
 }
 /**
  * Do a get on a key in region REGION_NAME. Keys to get are specified in keyIntervals.
  *
  * @return true if all keys to have get performaed have been completed.
  */
 protected boolean get() {
   SharedCounters sc = CQUtilBB.getBB().getSharedCounters();
   long nextKey = sc.incrementAndRead(CQUtilBB.LASTKEY_GET);
   if (!keyIntervals.keyInRange(KeyIntervals.GET, nextKey)) {
     Log.getLogWriter().info("All gets completed; returning from get");
     return true;
   }
   Object key = NameFactory.getObjectNameForCounter(nextKey);
   Log.getLogWriter().info("Getting " + key);
   try {
     Object existingValue = aRegion.get(key);
     Log.getLogWriter()
         .info(
             "Done getting "
                 + key
                 + ", num remaining: "
                 + (keyIntervals.getLastKey(KeyIntervals.GET) - nextKey));
     if (existingValue == null)
       throw new TestException("Get of key " + key + " returned unexpected " + existingValue);
   } catch (TimeoutException e) {
     throw new TestException(TestHelper.getStackTrace(e));
   } catch (CacheLoaderException e) {
     throw new TestException(TestHelper.getStackTrace(e));
   }
   return (nextKey >= keyIntervals.getLastKey(KeyIntervals.GET));
 }
  public void getRESTClientObject(Region region) {

    Object value1 = region.get("1");

    if (value1 instanceof PdxInstance) {
      System.out.println("InstanceOf PdxInstance " + value1.toString());

    } else System.out.println("NOt InstanceOf PdxInstance");
    /*
    Person value1 = (Person) region.get("1");
          System.out.println("Person Received on String type key =1 : " +  value1.toString());
          */
    /*
    Person value = (Person) region.get(1);
    if(value != null)
      System.out.println("Person Received on INT type key =1 : " +  value.toString());
    else
      System.out.println("Value got on INT key 1 is null");

    Person value2 = (Person) region.get(2);
    System.out.println("Person Received on int type key = 2 : " +  value2.toString());

    Person value3 = (Person) region.get("2");
    if(value3 != null){
      System.out.println("Person Received on String type key = 2 : " +  value3.toString());
    }else
      System.out.println("Value got on String key --> 2 is NULL VALUE ....!!");
    */
  }
  @Test
  public void create() {
    User bartSimpson = newUser("bartSimpson");

    usersTemplate.create(getKey(bartSimpson), bartSimpson);

    assertThat(users.containsKey(getKey(bartSimpson))).isTrue();
    assertThat(users.containsValueForKey(getKey(bartSimpson))).isTrue();
    assertThat(users.containsValue(bartSimpson)).isTrue();
    assertThat(users.get(getKey(bartSimpson))).isEqualTo(bartSimpson);
  }
  @Test
  public void putIfAbsent() {
    User stewieGriffon = newUser("stewieGriffon");

    assertThat(users.containsValue(stewieGriffon)).isFalse();
    assertThat(usersTemplate.putIfAbsent(getKey(stewieGriffon), stewieGriffon)).isNull();
    assertThat(users.containsValue(stewieGriffon)).isTrue();
    assertThat(usersTemplate.putIfAbsent(getKey(stewieGriffon), newUser("megGriffon")))
        .isEqualTo(stewieGriffon);
    assertThat(users.get(getKey(stewieGriffon))).isEqualTo(stewieGriffon);
  }
  @Test
  public void remove() {
    User mandyHandy = users.get(getKey(getUser("mandyHandy")));

    assertThat(mandyHandy).isNotNull();
    assertThat(usersTemplate.remove(getKey(mandyHandy))).isEqualTo(mandyHandy);
    assertThat(users.containsKey(getKey(mandyHandy))).isFalse();
    assertThat(users.containsValue(mandyHandy)).isFalse();
    assertThat(users.containsKey("loisGriffon")).isFalse();
    assertThat(usersTemplate.remove("loisGriffon")).isNull();
    assertThat(users.containsKey("loisGriffon")).isFalse();
  }
  /** do a get on region1 */
  public static void getValue2() {
    try {
      Region r = cache.getRegion(Region.SEPARATOR + REGION_NAME);
      if (!(r.get("key-1").equals("value-2"))) {
        fail("expected value to be value-2 but it is not so");
      }

    } catch (Exception ex) {
      ex.printStackTrace();
      fail("failed while region.get()", ex);
    }
  }
 @Test
 public void testIndexOnCommitForDestroy() throws Exception {
   AttributesFactory af = new AttributesFactory();
   af.setDataPolicy(DataPolicy.REPLICATE);
   Region region = cache.createRegion("sample", af.create());
   qs.createIndex("foo", IndexType.FUNCTIONAL, "age", "/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));
   utx.commit();
   Query q = qs.newQuery("select * from /sample where age < 50");
   assertEquals(1, ((SelectResults) q.execute()).size());
   Person dsample = (Person) CopyHelper.copy(region.get(x));
   dsample.setAge(55);
   utx.begin();
   region.destroy(x);
   utx.commit();
   CacheUtils.log(((Person) region.get(x)));
   assertEquals(0, ((SelectResults) q.execute()).size());
 }
  /**
   * 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 computeFactorials() {
   assertThat(factorials.get(0L), is(equalTo(1L)));
   assertThat(factorials.get(1L), is(equalTo(1L)));
   assertThat(factorials.get(2L), is(equalTo(2L)));
   assertThat(factorials.get(3L), is(equalTo(6L)));
   assertThat(factorials.get(4L), is(equalTo(24L)));
   assertThat(factorials.get(5L), is(equalTo(120L)));
   assertThat(factorials.get(6L), is(equalTo(720L)));
   assertThat(factorials.get(7L), is(equalTo(5040L)));
   assertThat(factorials.get(8L), is(equalTo(40320L)));
   assertThat(factorials.get(9L), is(equalTo(362880L)));
   assertThat(factorials.get(10L), is(equalTo(3628800L)));
 }
Beispiel #20
0
  public static int printEntries(Region region, Map keyMap, List keyList) throws Exception {
    if (region == null) {
      PadoShell.printlnError("Path is null");
      return 0;
    }

    HashSet keyNameSet = new HashSet();
    HashSet valueNameSet = new HashSet();
    ArrayList indexList = new ArrayList(keyMap.keySet());
    Collections.sort(indexList);
    Object key = null;
    Object value = null;

    // Print keys and values
    int row = 1;
    int rowCount = keyMap.size();
    for (Iterator iterator = indexList.iterator(); iterator.hasNext(); ) {
      Object index = iterator.next();
      key = keyMap.get(index);
      value = region.get(key);
      keyNameSet.add(key.getClass().getName());
      if (value != null) {
        valueNameSet.add(value.getClass().getName());
      }
      printObject(row, "Key", key, true);
      printObject(row, "Value", value, false);
      PadoShell.println("");
      row++;
    }

    PadoShell.println("");
    for (Object keyName : keyNameSet) {
      PadoShell.println("Key Class  : " + keyName);
    }
    for (Object valueName : valueNameSet) {
      PadoShell.println("Value Class: " + valueName);
    }
    return rowCount;
  }
  /**
   * Tests that if a <code>CacheLoader</code> for a local region invokes {@link
   * LoaderHelper#netSearch}, a {@link CacheLoaderException} is thrown.
   */
  public void testLocalLoaderNetSearch() throws CacheException {
    assertEquals(Scope.LOCAL, getRegionAttributes().getScope());

    final String name = this.getUniqueName();
    final Object key = this.getUniqueName();

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

            try {
              helper.netSearch(true);

            } catch (TimeoutException ex) {
              fail("Why did I timeout?", ex);
            }

            return null;
          }
        };

    AttributesFactory factory = new AttributesFactory(getRegionAttributes());
    factory.setCacheLoader(loader);
    Region region = createRegion(name, factory.create());
    assertEquals(Scope.LOCAL, region.getAttributes().getScope());

    try {
      region.get(key);
      fail("Should have thrown a CacheLoaderException");

    } catch (CacheLoaderException ex) {
      String expected =
          com.gemstone.gemfire.internal.cache.LoaderHelperImpl.NET_SEARCH_LOCAL.toLocalizedString();
      String message = ex.getMessage();
      assertTrue("Unexpected message \"" + message + "\"", message.indexOf(expected) != -1);
    }
  }
  /**
   * Tests that we are in {@link GemFireHealth#OKAY_HEALTH okay} health if cache loads take too
   * long.
   *
   * @see CacheHealthEvaluator#checkLoadTime
   */
  public void testCheckLoadTime() throws CacheException {
    Cache cache = CacheFactory.create(this.system);
    CachePerfStats stats = ((GemFireCacheImpl) 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.setMaxLoadTime(100);

    CacheHealthEvaluator eval =
        new CacheHealthEvaluator(config, this.system.getDistributionManager());
    for (int i = 0; i < 10; i++) {
      region.get("Test1 " + i);
    }
    long firstLoadTime = stats.getLoadTime();
    long firstLoadsCompleted = stats.getLoadsCompleted();
    assertTrue(firstLoadTime >= 0);
    assertTrue(firstLoadsCompleted > 0);

    // First time should always be empty
    List status = new ArrayList();
    eval.evaluate(status);
    assertEquals(0, status.size());

    config = new GemFireHealthConfigImpl(null);
    config.setMaxLoadTime(10);
    eval = new CacheHealthEvaluator(config, this.system.getDistributionManager());
    eval.evaluate(status);

    long start = System.currentTimeMillis();
    for (int i = 0; i < 100; i++) {
      region.get("Test2 " + i);
    }
    assertTrue(System.currentTimeMillis() - start < 1000);
    long secondLoadTime = stats.getLoadTime();
    long secondLoadsCompleted = stats.getLoadsCompleted();
    assertTrue(
        "firstLoadTime=" + firstLoadTime + ", secondLoadTime=" + secondLoadTime,
        secondLoadTime >= firstLoadTime);
    assertTrue(secondLoadsCompleted > firstLoadsCompleted);

    // Averge should be less than 10 milliseconds
    status = new ArrayList();
    eval.evaluate(status);
    assertEquals(0, status.size());

    region
        .getAttributesMutator()
        .setCacheLoader(
            new CacheLoader() {
              public Object load(LoaderHelper helper) throws CacheLoaderException {

                try {
                  Thread.sleep(20);

                } catch (InterruptedException ex) {
                  fail("Why was I interrupted?");
                }
                return "Loaded";
              }

              public void close() {}
            });

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

    long thirdLoadTime = stats.getLoadTime();
    long thirdLoadsCompleted = stats.getLoadsCompleted();
    assertTrue(thirdLoadTime > secondLoadTime);
    assertTrue(thirdLoadsCompleted > secondLoadsCompleted);

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

    AbstractHealthEvaluator.HealthStatus ill = (AbstractHealthEvaluator.HealthStatus) status.get(0);
    assertEquals(GemFireHealth.OKAY_HEALTH, ill.getHealthCode());
    String s = "The average duration of a Cache load";
    assertTrue(ill.getDiagnosis().indexOf(s) != -1);
  }
  /**
   * *********** private static String verifyPdxInstanceToJSONConversion(Region region) {
   * System.out.println("START Execute REST-APIs testcases..."); System.out.println("Step:1
   * PdxInstance ---------> JSON conversion"); Cache c = CacheFactory.getAnyInstance(); region =
   * c.getRegion("primitiveKVStore");
   *
   * <p>//PUT TestObjectForPdxFormatter testObject = new TestObjectForPdxFormatter();
   * testObject.defaultInitialization();
   *
   * <p>// ObjectMapper mapper = new ObjectMapper(); mapper.setDateFormat(new
   * SimpleDateFormat("MM/dd/yyyy"));
   * mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); String jsonString =
   * null; try { jsonString = mapper.writeValueAsString(testObject); } catch
   * (JsonProcessingException e1) { // TODO Auto-generated catch block e1.printStackTrace(); }
   *
   * <p>//CollectionType mapCollectionType = mapper.getTypeFactory().defaultInstance()
   * constructCollectionType(List.class, Map.class); //TestObjectForPdxFormatter newObj =
   * mapper.readValue(jsonStr, clazz); //Object newObj = clazz.newInstance(); //String jsonStr =
   * JSONFormatter.toJSON(this);
   *
   * <p>System.out.println("PdxInstance converted to JSON is :: " + jsonString); //JavaType type =
   * mapper.getTypeFactory().constructType(newObj.getClass());
   *
   * <p>try { TestObjectForPdxFormatter newObj = mapper.readValue(jsonString,
   * TestObjectForPdxFormatter.class);
   *
   * <p>System.out.println("JSON to Object Conversion successful"); } catch (JsonParseException e1)
   * { // TODO Auto-generated catch block e1.printStackTrace(); } catch (JsonMappingException e1) {
   * // TODO Auto-generated catch block e1.printStackTrace(); } catch (IOException e1) { // TODO
   * Auto-generated catch block e1.printStackTrace(); }
   *
   * <p>System.out.println("TEST END"); //
   *
   * <p>System.out.println("-----------------------------------JAVA CLIENT PUT-14 START
   * -----------------------------------------------------"); region.put("14", testObject);
   * System.out.println("-----------------------------------JAVA CLIENT PUT-14 END
   * ------------------------------------------------------"); System.out.println();
   *
   * <p>System.out.println("-----------------------------------JAVA CLIENT GET('13'), this was put
   * by peer cache - START -----------------------------------------------------"); Object clientObj
   * = (Object)region.get("13"); if (clientObj instanceof PdxInstance) { PdxInstance pi =
   * (PdxInstance)clientObj; String clazzName = pi.getClassName(); System.out.println("CLAZZ_1 : " +
   * clazzName); }else { System.out.println("clientObj is not PdxInstance,
   * clientObj.getClass().getName() : " + clientObj.getClass().getName()); }
   * System.out.println("-----------------------------------JAVA CLIENT GET('13') - END
   * ------------------------------------------------------"); System.out.println();
   *
   * <p>System.out.println("-----------------------------------JAVA CLIENT GET('14'), this was put
   * by Java client - START -----------------------------------------------------"); Object
   * clientObj2 = (Object)region.get("14"); if (clientObj2 instanceof PdxInstance) { PdxInstance pi
   * = (PdxInstance)clientObj2; String clazzName = pi.getClassName(); System.out.println("CLAZZ_2 :
   * " + clazzName); }else { System.out.println("clientObj2 is not PdxInstance,
   * clientObj2.getClass().getName() : " + clientObj2.getClass().getName()); }
   * System.out.println("-----------------------------------JAVA CLIENT GET('14') - END
   * ------------------------------------------------------"); System.out.println();
   *
   * <p>//Put PdxInstance System.out.println("-----------------------------------JAVA CLIENT
   * PDXInstance Put('15') - START -----------------------------------------"); //PdxInstanceFactory
   * pif = PdxInstanceFactoryImpl.newCreator("com.gemstone.gemfire.pdx.TestObjectForPdxFormatter",
   * true); PdxInstanceFactory pif =
   * c.createPdxInstanceFactory("com.gemstone.gemfire.pdx.TestObjectForPdxFormatter");
   *
   * <p>pif.writeLong("p_long", 1000000000000L); pif.writeFloat("p_float",100.001f);
   * pif.writeDouble("p_double", 100000.100000); pif.writeBoolean("p_bool", true);
   * pif.writeByte("p_byte", (byte)10); pif.writeInt("p_int", 1000); pif.writeShort("p_short",
   * (short)100);
   *
   * <p>PdxInstance pInst = pif.create(); region.put("15", pInst);
   * System.out.println("-----------------------------------JAVA CLIENT PDXInstance Put('15') - END
   * -----------------------------------------"); System.out.println();
   *
   * <p>//GET System.out.println("-----------------------------------JAVA CLIENT PDXInstance
   * Get('15') - START -----------------------------------------"); Object result =
   * (Object)region.get("15"); if (result instanceof PdxInstance) { //Output: result is instance of
   * PdxInstance PdxInstance pi = (PdxInstance)result; String clazzName = pi.getClassName();
   * System.out.println("CLAZZ_2 : " + clazzName); //1. check for getObject() behaviour try{ Object
   * obj = pi.getObject();
   *
   * <p>if(obj instanceof TestObjectForPdxFormatter){ //OutPut: piAsObject instanceof
   * TestObjectForPdxFormatter System.out.println(" piAsObject instanceof TestObjectForPdxFormatter
   * "); }else System.out.println(" piAsObject NOT TestObjectForPdxFormatter ");
   * }catch(PdxSerializationException ex){ System.out.println("Error " + ex.getMessage());
   * ex.printStackTrace(); } //2. introspectPdxInstanceFields //introspectPdxInstanceFields(pi);
   *
   * <p>//3. Verify pi to json conversion String json = JSONFormatter.toJSON(pi);
   * System.out.println("JSON Result " + json ); return json; } else { try {
   * System.out.println("Result not a pdxInstance result.getClass().getName():: " +
   * result.getClass().getName()); }catch(PdxFieldTypeMismatchException e){
   * System.out.println("Error PdxFieldTypeMismatchException : " + e.getMessage()); } }
   *
   * <p>System.out.println("-----------------------------------JAVA CLIENT PDXInstance Get('15') -
   * END -----------------------------------------"); System.out.println();
   *
   * <p>//TODO:: REST CLEINT Does PUT on key 16
   *
   * <p>//GET System.out.println("-----------------------------------REST CLIENT PDXInstance
   * Get('16') - START -----------------------------------------"); Object result2 =
   * (Object)region.get("16"); if (result2 instanceof PdxInstance) { //Output: result is instance of
   * PdxInstance PdxInstance pi = (PdxInstance)result2; String clazzName = pi.getClassName();
   * System.out.println("CLAZZ_3 : " + clazzName); //1. check for getObject() behaviour try{ Object
   * obj = pi.getObject();
   *
   * <p>if(obj instanceof TestObjectForPdxFormatter){ //OutPut: piAsObject instanceof
   * TestObjectForPdxFormatter System.out.println(" piAsObject instanceof TestObjectForPdxFormatter
   * "); }else System.out.println(" piAsObject NOT TestObjectForPdxFormatter ");
   * }catch(PdxFieldTypeMismatchException e){ System.out.println("Error
   * PdxFieldTypeMismatchException : " + e.getMessage()); }catch(PdxSerializationException ex){
   * System.out.println("Error " + ex.getMessage()); ex.printStackTrace(); } //2.
   * introspectPdxInstanceFields //introspectPdxInstanceFields(pi);
   *
   * <p>//3. Verify pi to json conversion String json = JSONFormatter.toJSON(pi);
   * System.out.println("JSON Result " + json ); return json; } else { System.out.println("Result
   * not a pdxInstance result2.getClass().getName():: " + result2.getClass().getName()); }
   *
   * <p>System.out.println("-----------------------------------JAVA CLIENT PDXInstance Get('15') -
   * END -----------------------------------------"); System.out.println(); return null; }
   *
   * <p>private static final String ORDER2_AS_JSON = "{" + "\"@type\":
   * \"com.gemstone.gemfire.web.rest.domain.Order\"," + "\"purchaseOrderNo\": 112," +
   * "\"customerId\": 102," + "\"description\": \"Purchase order for company - B\"," +
   * "\"orderDate\": \"02/10/2014\"," + "\"deliveryDate\": \"02/20/2014\"," + "\"contact\": \"John
   * Blum\"," + "\"email\": \"[email protected]\"," + "\"phone\": \"01-2048096\"," +
   * "\"totalPrice\": 225," + "\"items\":" + "[" + "{" + "\"itemNo\": 1," + "\"description\":
   * \"Product-3\"," + "\"quantity\": 6," + "\"unitPrice\": 20," + "\"totalPrice\": 120" + "}," +
   * "{" + "\"itemNo\": 2," + "\"description\": \"Product-4\"," + "\"quantity\": 10," +
   * "\"unitPrice\": 10.5," + "\"totalPrice\": 105" + "}" + "]" + "}";
   *
   * <p>private static HttpHeaders setAcceptAndContentTypeHeaders() { List<MediaType>
   * acceptableMediaTypes = new ArrayList<MediaType>();
   * acceptableMediaTypes.add(MediaType.APPLICATION_JSON);
   *
   * <p>HttpHeaders headers = new HttpHeaders(); headers.setAccept(acceptableMediaTypes);
   * headers.setContentType(MediaType.APPLICATION_JSON); return headers; }
   *
   * <p>private static void ValidateTestCase(){
   *
   * <p>Cache c = CacheFactory.getAnyInstance(); Region region = c.getRegion("orders");
   *
   * <p>//Rest put on key:2 HttpHeaders headers = setAcceptAndContentTypeHeaders();
   * HttpEntity<Object> entity = new HttpEntity<Object>(ORDER2_AS_JSON, headers);
   *
   * <p>ResponseEntity<String> result = RestTestUtils.getRestTemplate().exchange(
   * RestTestUtils.GEMFIRE_REST_API_WEB_SERVICE_URL + "/orders/2", HttpMethod.PUT, entity,
   * String.class);
   *
   * <p>//PUT Item it = new Item(); it.setItemNo(1L); it.setDescription("Free Item -- testing");
   * it.setQuantity(10); it.setTotalPrice(250.10f); it.setUnitPrice(25.01f);
   *
   * <p>Object obj = region.get("2"); if(obj instanceof PdxInstance) { PdxInstance pi =
   * (PdxInstance)obj; Order receivedOrder = (Order)pi.getObject();
   *
   * <p>//System.out.println("Original order size:: " + receivedOrder.getItems().size());
   * //receivedOrder.addItem(it); //System.out.println("Updated order size:: " +
   * receivedOrder.getItems().size()); region.put("3", receivedOrder); }
   *
   * <p>//GET Object updResult = region.get("3"); if (updResult instanceof PdxInstance) {
   * System.out.println("updResult is instance of PdxInstance...!!");
   *
   * <p>System.out.println("Step:1 PdxInstance ---------> JSON conversion"); PdxInstance pi =
   * (PdxInstance)updResult;
   *
   * <p>try{
   *
   * <p>Object piObj = pi.getObject(); if(piObj instanceof Order){ System.out.println("step-1.
   * piAsObject instanceof Order "); }else System.out.println("step-1: piAsObject NOT Order ");
   *
   * <p>}catch(PdxSerializationException ex){ System.out.println("Error " + ex.getMessage());
   * ex.printStackTrace(); } }
   *
   * <p>System.out.println("successfully Put TestObjectForPdxFormatter into the cache");
   *
   * <p>///System.out.println("Nilkanth : TestCase : Validate Java-->JSON-->PdxInstance --> Java
   * Mapping");
   *
   * <p>System.out.println("START Execute REST-APIs testcases..."); System.out.println("Step:1
   * PdxInstance ---------> JSON conversion"); //Cache c = CacheFactory.getAnyInstance(); region =
   * c.getRegion("primitiveKVStore");
   *
   * <p>TestObjectForPdxFormatter actualTestObject = new TestObjectForPdxFormatter();
   * actualTestObject.defaultInitialization(); ObjectMapper objectMapper = new ObjectMapper();
   * objectMapper.setDateFormat(new SimpleDateFormat("MM/dd/yyyy"));
   * objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); try { //1.
   * get the json from the object using Jackosn Object Mapper String json =
   * objectMapper.writeValueAsString(actualTestObject); String jsonWithClassType =
   * actualTestObject.addClassTypeToJson(json); System.out.println("Nilkanth : jsonWithClassType:: "
   * + jsonWithClassType);
   *
   * <p>//2. convert json into the PdxInstance and put it into the region PdxInstance pi =
   * JSONFormatter.fromJSON(jsonWithClassType); region.put("201", pi);
   *
   * <p>//3. get the value on key "201" and validate PdxInstance.getObject() API. Object
   * receivedObject = region.get("201"); if (receivedObject instanceof PdxInstance){ PdxInstance
   * receivedPdxInstance = (PdxInstance)receivedObject;
   *
   * <p>//4. get the actual testObject from the pdxInstance and compare it with actualTestObject
   * Object getObj = receivedPdxInstance.getObject(); if(getObj instanceof
   * TestObjectForPdxFormatter){ TestObjectForPdxFormatter receivedTestObject =
   * (TestObjectForPdxFormatter)getObj;
   *
   * <p>boolean isEqual = actualTestObject.equals(receivedTestObject); Assert.assertTrue(isEqual,
   * "actualTestObject and receivedTestObject should be equal"); }else { System.out.println("Error:
   * getObj is expected to be an instance of TestObjectForPdxFormatter"); } }else {
   * System.out.println("ERROR:: receivedObject is expected to be of type PdxInstance"); }
   *
   * <p>} catch (JsonProcessingException e) { System.out.println("Error:JsonProcessingException:
   * error encountered while converting JSON from Java object: " + e.getMessage());
   *
   * <p>} catch (JSONException e) { System.out.println("Error:JSONException: error encountered while
   * adding @type classType into Json: " + e.getMessage()); } }
   */
  public static void main(String[] args) {
    /*CacheFactory cf = new CacheFactory();
    Cache cache = cf.create();
    RegionFactory rf = cache.createRegionFactory();
    Region region = rf.create("Test1");*/

    ClientCacheFactory cf =
        new ClientCacheFactory()
            .addPoolServer(
                "localhost",
                40405); /// *.addPoolLocator("10.112.204.2" /*pnq-npatel1*//*"localhost"*/,
                        // 11240)*/;
    // ClientCache cache = cf.setPdxReadSerialized(true).create();
    ClientCache cache = cf.create();
    ClientRegionFactory rf = cache.createClientRegionFactory(ClientRegionShortcut.PROXY);

    Region region = rf.create("People");
    // Region region1 = rf.create("orders");

    Person actualObj = null;
    Object obj = region.get("1");
    if (obj instanceof PdxInstance) {
      System.out.println("Obj is PdxInstance");
      PdxInstance pi = (PdxInstance) obj;
      Object obj2 = pi.getObject();
      if (obj2 instanceof Person) {
        actualObj = (Person) obj2;
        System.out.println("Received Person :" + actualObj.toString());
      } else {
        System.out.println("Error: obj2 is expected to be of type Person");
      }
    } else {
      System.out.println("Error: obj is expected to be of type PdxInstance");
    }

    // update the received object and put it in cache
    if (actualObj != null) {
      actualObj.setFirstName("Nilkanth_updated");
      actualObj.setLastName("Patel_updated");
      region.put("1", actualObj);
    }

    // Add/putAll set of person objects
    final Person person2 =
        new Person(
            102L,
            "Sachin",
            "Ramesh",
            "Tendulkar",
            DateTimeUtils.createDate(1975, Calendar.DECEMBER, 14),
            Gender.MALE);
    final Person person3 =
        new Person(
            103L,
            "Saurabh",
            "Baburav",
            "Ganguly",
            DateTimeUtils.createDate(1972, Calendar.AUGUST, 29),
            Gender.MALE);
    final Person person4 =
        new Person(
            104L,
            "Rahul",
            "subrymanyam",
            "Dravid",
            DateTimeUtils.createDate(1979, Calendar.MARCH, 17),
            Gender.MALE);
    final Person person5 =
        new Person(
            105L,
            "Jhulan",
            "Chidambaram",
            "Goswami",
            DateTimeUtils.createDate(1983, Calendar.NOVEMBER, 25),
            Gender.FEMALE);

    final Person person6 =
        new Person(
            101L,
            "Rahul",
            "Rajiv",
            "Gndhi",
            DateTimeUtils.createDate(1970, Calendar.MAY, 14),
            Gender.MALE);
    final Person person7 =
        new Person(
            102L,
            "Narendra",
            "Damodar",
            "Modi",
            DateTimeUtils.createDate(1945, Calendar.DECEMBER, 24),
            Gender.MALE);
    final Person person8 =
        new Person(
            103L,
            "Atal",
            "Bihari",
            "Vajpayee",
            DateTimeUtils.createDate(1920, Calendar.AUGUST, 9),
            Gender.MALE);
    final Person person9 =
        new Person(
            104L,
            "Soniya",
            "Rajiv",
            "Gandhi",
            DateTimeUtils.createDate(1929, Calendar.MARCH, 27),
            Gender.FEMALE);
    final Person person10 =
        new Person(
            104L,
            "Priyanka",
            "Robert",
            "Gandhi",
            DateTimeUtils.createDate(1973, Calendar.APRIL, 15),
            Gender.FEMALE);

    final Person person11 =
        new Person(
            104L,
            "Murali",
            "Manohar",
            "Joshi",
            DateTimeUtils.createDate(1923, Calendar.APRIL, 25),
            Gender.MALE);
    final Person person12 =
        new Person(
            104L,
            "Lalkrishna",
            "Parmhansh",
            "Advani",
            DateTimeUtils.createDate(1910, Calendar.JANUARY, 01),
            Gender.MALE);
    final Person person13 =
        new Person(
            104L,
            "Shushma",
            "kumari",
            "Swaraj",
            DateTimeUtils.createDate(1943, Calendar.AUGUST, 10),
            Gender.FEMALE);
    final Person person14 =
        new Person(
            104L,
            "Arun",
            "raman",
            "jetly",
            DateTimeUtils.createDate(1942, Calendar.OCTOBER, 27),
            Gender.MALE);
    final Person person15 =
        new Person(
            104L,
            "Amit",
            "kumar",
            "shah",
            DateTimeUtils.createDate(1958, Calendar.DECEMBER, 21),
            Gender.MALE);
    final Person person16 =
        new Person(
            104L,
            "Shila",
            "kumari",
            "Dixit",
            DateTimeUtils.createDate(1927, Calendar.FEBRUARY, 15),
            Gender.FEMALE);

    Map<String, Object> userMap = new HashMap<String, Object>();
    userMap.put("2", person6);
    userMap.put("3", person6);
    userMap.put("4", person6);
    userMap.put("5", person6);
    userMap.put("6", person6);
    userMap.put("7", person7);
    userMap.put("8", person8);
    userMap.put("9", person9);
    userMap.put("10", person10);
    userMap.put("11", person11);
    userMap.put("12", person12);
    userMap.put("13", person13);
    userMap.put("14", person14);
    userMap.put("15", person15);
    userMap.put("16", person16);

    region.putAll(userMap);

    System.out.println("successfully Put set of Person objects into the cache");

    region.invalidate("2");
    region.invalidate("3");
    region.invalidate("4");
    region.invalidate("5");
    region.invalidate("6");
    region.invalidate("7");
    region.invalidate("8");

    region.remove("9");
    region.remove("10");

    /*
    Object obj = region.get("13");
    if(obj instanceof PdxInstance){
    	System.out.println("Obj is PdxInstance");
    }else {
    	System.out.println("Obj isNOT  PdxInstance");
    }
    */

    // verifyPdxInstanceToJSONConversion(region);
    // ValidateTestCase();

    /*
    RegionOps regionOps = new RegionOps();

    regionOps.getRESTClientObject(region);

    //2.Test cases with PortfolioPdx of type PdxSerialization
    //create PortfolioPdx object
    PortfolioPdx portPdx = new PortfolioPdx(10);
    System.out.println("portPdx.toString() = " + portPdx.toString());

    ObjectMapper mapper = new ObjectMapper();
    mapper.setDateFormat(new SimpleDateFormat("MM/dd/yyyy"));
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    String jsonString = null;
    try {
    	jsonString = mapper.writeValueAsString(portPdx);

    } catch (JsonProcessingException e) {
    	System.out.println("Error: JsonProcessingException caught");
    	// 	TODO Auto-generated catch block
    	e.printStackTrace();
    }

    System.out.println("Success: cust1 as JSON " + jsonString);

    //put the object into cache.
    region.put("11", portPdx);
    System.out.println("successfully Put PortfolioPdx into the cache");

    Boolean b = new Boolean(false);
    Byte by = new Byte((byte)11);
    Short sh = new Short((short)101);
    Integer in = new Integer(1001);
    Long lo = new Long(987654321234567L);
    BigInteger bi = new BigInteger("12345678910");
    Float fl = new Float(789.456f);
    BigDecimal bd = new BigDecimal(8866333);
    Double doub = new Double(123456.9876d);
    String str = new String("Nilkanth Patel");
    */

    /*
    TestObjectForPdxFormatter testObject = new TestObjectForPdxFormatter(true, (byte)10, (short)100, 1000, 1234567898765432L, 123.456f, 98765.12345d,
    		b, by, sh, in, lo, bi ,fl, bd ,doub, str
    		);
    */

    /*
    TestObjectForPdxFormatter testObject = new TestObjectForPdxFormatter();
    testObject.defaultInitialization();

    System.out.println("testObject.toString() = " + testObject.toString());

    jsonString = null;
    try {
    	jsonString = mapper.writeValueAsString(testObject);

    } catch (JsonProcessingException e) {
    	System.out.println("Error: JsonProcessingException caught");
    	// 	TODO Auto-generated catch block
    	e.printStackTrace();
    }

    System.out.println("Success: testObject as JSON " + jsonString);

    //put the object into cache.
    region.put("13", testObject);
    */
    /*
    Object result = (Object)region.get("13");
    if (result instanceof PdxInstance) {
      System.out.println("result is instance of PdxInstance...!!");

      System.out.println("Step:1 PdxInstance to JSON conversion");
      PdxInstance pi = (PdxInstance)result;

      String json = JSONFormatter.toJSON(pi);
      System.out.println("JSON Result " + json );


      System.out.println("Step:2 JSON to PdxInstance conversion");
      PdxInstance pInstance = JSONFormatter.fromJSON(json);
      Object piAsObject = pInstance.getObject();


      if(piAsObject instanceof TestObjectForPdxFormatter){
    	  System.out.println("piAsObject instanceof TestObjectForPdxFormatter ");
      }else {
    	  System.out.println("piAsObject NOT of type TestObjectForPdxFormatter");
      }
    }else {
    	System.out.println("Error: result not PDXInstance type");
    }

    */

    //
    // regionOps.putJavaClientObject(region);

    /*JSONObject json = new JSONObject();

                String key = "key";
                Object value = "501";
                try {
    	json.put(key, value);
    } catch (JSONException e) {
    	// TODO Auto-generated catch block
    	e.printStackTrace();
    }
                //String json = "{ " + "\"" + key.toString() +  "\"" + ":" + value + "}";
                //System.out.println(" JSON :: " + json);
                System.out.println("JSON :: " + json.toString());
                */

    // 1.START:: Test cases with Person of type DataSerializable
    // put and then get Person object
    /**
     * ************************************* Person p1 = new Person(10l); p1.setFirstName("Diya");
     * p1.setMiddleName("Sandipkumar"); p1.setLastName("Patel"); p1.setGender(Gender.FEMALE);
     * p1.setBirthDate(DateTimeUtils.createDate(2009, Calendar.OCTOBER, 3));
     *
     * <p>//put region.put("10", p1); System.out.println("person1.toString() = " + p1.toString());
     *
     * <p>//get Person person = (Person)region.get("10"); if(person instanceof Person){
     * System.out.println("Instance of Person"); System.out.println("firstname = " +
     * person.getFirstName() + " Lastname = " + person.getLastName()); }else{
     * System.out.println("NOT Instance of Person"); } //END:: Test cases with Person of type
     * DataSerializable
     *
     * <p>//PdxInstance pi = (PdxInstance) cache.createPdxInstanceFactory("").writeString("key1",
     * "key2").create(); //PPerson person = new PPerson(1, "Sachin", "Tendulkar");
     * //PdxInstanceFactory pdxFact = PdxInstanceFactoryImpl.newCreator(name, expectDomainClass)
     *
     * <p>//2.Test cases with PortfolioPdx of type PdxSerialization //create PortfolioPdx object
     * PortfolioPdx portPdx = new PortfolioPdx(10); System.out.println("portPdx.toString() = " +
     * portPdx.toString());
     *
     * <p>//put the object into cache. region.put("11", portPdx);
     * ***************************************
     */
    //
    // put/get code with serialized read behavior
    // put is done as normal
    // region.put("11", portPdx);

    // get checks Object type and handles each appropriately
    // Object myObject = region.get("11");
    /*
    if (myObject instanceof PdxInstance) {
    	// get returned PdxInstance instead of domain object
    	PdxInstance myPdxInstance = (PdxInstance)myObject;

    	String myJson = JSONFormatter.toJSON(myPdxInstance);

    	System.out.println(" my JSOn :: " + myJson);

    	// PdxInstance.getField deserializes the field, but not the object
    	String fieldValue = (String) myPdxInstance.getField("pkid");

    	System.out.println("RESULT ---> " + fieldValue);
    	// Update a field and put it back into the cache
    	// without deserializing the entire object

    	//WritablePdxInstance myWritablePdxI = myPdxInstance.createWriter();
    	//myWritablePdxI.setField("fieldName", fieldValue);
    	//region.put(key, myWritablePdxI);

    	// Deserialize the entire object if needed, from the PdxInstance

    	//DomainClass myPdxObject = (DomainClass);

    //
    } else if (myObject instanceof PdxSerializable) {
    	System.out.println("Object is PDXSerializable...");

    } else {
    	System.out.println("ERROR ----> Object is not PDXInstance NOR PDXSerializable ");
    }
    */
    System.out.println("TEST Ended Successfully....!!!!");

    /*
      final Set<Region<?, ?>> regionSet =  cache.rootRegions();

      System.out.println("Following are the regions found in the Server");
      for(Region<?, ?> r : regionSet){
      	System.out.println(r.getName());

      }
      GetRegions myFunction = new GetRegions();

      //PoolImpl p = (PoolImpl) PoolManager.createFactory().addServer("localhost", 12480);
      FunctionService.registerFunction(myFunction);

      //Map<String, Function> myMap = FunctionService.getRegisteredFunctions();

      //System.out.println("Total size for registered functions ::: " + myMap.size());

      Execution exe = FunctionService.onServer(cache.getDefaultPool());

      System.out.println("Executing the function");

      ResultCollector<?, ?> rc =  exe.execute("GetRegions");

      ArrayList result = (ArrayList)rc.getResult();

      List<String> list = (List<String>)result.get(0);
      System.out.println(" Region at the index 0 is " +  list.get(0));

      System.out.println(" Region at the index 1 is " +  list.get(1));

    System.out.println("Function executed remotelly successfully , Size is = "  + result.size());

      //ResultCollector rc = exe.execute(new PutKeyFunction() {  GemFireCacheImpl.getExisting(null).rootRegions()});

      //Set result = (Set) rc.getResult();

      //System.out.println("Function executed remotelly successfully , Size is = "  + result.size());
      */
    /*Execution execution = FunctionService.onRegion(exampleRegion).withFilter(
             keysForGet).withArgs(Boolean.TRUE).withCollector(
             new MyArrayListResultCollector());
         ResultCollector rc = execution.execute(function);

    */
    /*
    Person p = new Person();

    p.setId(101L);
    p.setFirstName("Nilkanth");
    p.setLastName("Patel");
    p.setMiddleName("Hirabhai");
    p.setBirthDate(DateTimeUtils.createDate(1983, Calendar.JUNE, 1));
    p.setGender(Gender.MALE);

    region.put(1,p);

    ////////////////////////////
    p.setId(102L);
    p.setFirstName("Hemant");
    p.setLastName("Bhanavat");
    p.setMiddleName("Unknown");
    p.setBirthDate(DateTimeUtils.createDate(1980, Calendar.JANUARY, 1));
    p.setGender(Gender.MALE);

    region.put(2,p);

    //////////////////////////
    p.setId(103L);
    p.setFirstName("TUshar");
    p.setLastName("Khairnar");
    p.setMiddleName("Unknown");
    p.setBirthDate(DateTimeUtils.createDate(1983, Calendar.JUNE, 15));
    p.setGender(Gender.MALE);

    region.put(3,p);
    region.put(2,2);
    region.put(3,3);
    region.put(4,4);
    region.put(5,5);
    */
    // System.out.println("Hello!!!!!");

    /*System.out.println(region.get(1));
    System.out.println(region.get(2));
    System.out.println(region.get(3));
    System.out.println(region.get(4));
    System.out.println(region.get(5));
    */

  }
  /**
   * Verify the contents of the region, taking into account the keys that were destroyed,
   * invalidated, etc (as specified in keyIntervals) Throw an error of any problems are detected.
   * This must be called repeatedly by the same thread until StopSchedulingTaskOnClientOrder is
   * thrown.
   */
  public void verifyRegionContents() {
    final long LOG_INTERVAL_MILLIS = 10000;
    // we already completed this check once; we can't do it again without reinitializing the
    // verify state variables
    if (verifyRegionContentsCompleted) {
      throw new TestException(
          "Test configuration problem; already verified region contents, "
              + "cannot call this task again without resetting batch variables");
    }

    // iterate keys
    long lastLogTime = System.currentTimeMillis();
    long minTaskGranularitySec = TestConfig.tab().longAt(TestHelperPrms.minTaskGranularitySec);
    long minTaskGranularityMS = minTaskGranularitySec * TestHelper.SEC_MILLI_FACTOR;
    long startTime = System.currentTimeMillis();
    long size = aRegion.size();
    boolean first = true;
    int numKeysToCheck = keyIntervals.getNumKeys() + numNewKeys;
    while (verifyRegionContentsIndex < numKeysToCheck) {
      verifyRegionContentsIndex++;
      if (first) {
        Log.getLogWriter()
            .info(
                "In verifyRegionContents, region has "
                    + size
                    + " keys; starting verify at verifyRegionContentsIndex "
                    + verifyRegionContentsIndex
                    + "; verifying key names with indexes through (and including) "
                    + numKeysToCheck);
        first = false;
      }

      // check region size the first time through the loop to avoid it being called
      // multiple times when this is batched
      if (verifyRegionContentsIndex == 1) {
        if (totalNumKeys != size) {
          String tmpStr = "Expected region size to be " + totalNumKeys + ", but it is size " + size;
          Log.getLogWriter().info(tmpStr);
          verifyRegionContentsErrStr.append(tmpStr + "\n");
        }
      }

      Object key = NameFactory.getObjectNameForCounter(verifyRegionContentsIndex);
      try {
        if (((verifyRegionContentsIndex >= keyIntervals.getFirstKey(KeyIntervals.NONE))
                && (verifyRegionContentsIndex <= keyIntervals.getLastKey(KeyIntervals.NONE)))
            || ((verifyRegionContentsIndex >= keyIntervals.getFirstKey(KeyIntervals.GET))
                && (verifyRegionContentsIndex <= keyIntervals.getLastKey(KeyIntervals.GET)))) {
          // this key was untouched after its creation
          checkContainsKey(key, true, "key was untouched");
          checkContainsValueForKey(key, true, "key was untouched");
          Object value = aRegion.get(key);
          checkValue(key, value);
        } else if ((verifyRegionContentsIndex >= keyIntervals.getFirstKey(KeyIntervals.INVALIDATE))
            && (verifyRegionContentsIndex <= keyIntervals.getLastKey(KeyIntervals.INVALIDATE))) {
          checkContainsKey(key, true, "key was invalidated");
          checkContainsValueForKey(key, false, "key was invalidated");
        } else if ((verifyRegionContentsIndex
                >= keyIntervals.getFirstKey(KeyIntervals.LOCAL_INVALIDATE))
            && (verifyRegionContentsIndex
                <= keyIntervals.getLastKey(KeyIntervals.LOCAL_INVALIDATE))) {
          // this key was locally invalidated
          checkContainsKey(key, true, "key was locally invalidated");
          checkContainsValueForKey(key, true, "key was locally invalidated");
          Object value = aRegion.get(key);
          checkValue(key, value);
        } else if ((verifyRegionContentsIndex >= keyIntervals.getFirstKey(KeyIntervals.DESTROY))
            && (verifyRegionContentsIndex <= keyIntervals.getLastKey(KeyIntervals.DESTROY))) {
          // this key was destroyed
          checkContainsKey(key, false, "key was destroyed");
          checkContainsValueForKey(key, false, "key was destroyed");
        } else if ((verifyRegionContentsIndex
                >= keyIntervals.getFirstKey(KeyIntervals.LOCAL_DESTROY))
            && (verifyRegionContentsIndex <= keyIntervals.getLastKey(KeyIntervals.LOCAL_DESTROY))) {
          // this key was locally destroyed
          checkContainsKey(key, true, "key was locally destroyed");
          checkContainsValueForKey(key, true, "key was locally destroyed");
          Object value = aRegion.get(key);
          checkValue(key, value);
        } else if ((verifyRegionContentsIndex
                >= keyIntervals.getFirstKey(KeyIntervals.UPDATE_EXISTING_KEY))
            && (verifyRegionContentsIndex
                <= keyIntervals.getLastKey(KeyIntervals.UPDATE_EXISTING_KEY))) {
          // this key was updated
          checkContainsKey(key, true, "key was updated");
          checkContainsValueForKey(key, true, "key was updated");
          Object value = aRegion.get(key);
          checkUpdatedValue(key, value);
        } else if (verifyRegionContentsIndex > keyIntervals.getNumKeys()) {
          // key was newly added
          checkContainsKey(key, true, "key was new");
          checkContainsValueForKey(key, true, "key was new");
          Object value = aRegion.get(key);
          checkValue(key, value);
        }
      } catch (TestException e) {
        Log.getLogWriter().info(TestHelper.getStackTrace(e));
        verifyRegionContentsErrStr.append(e.getMessage() + "\n");
      }

      if (System.currentTimeMillis() - lastLogTime > LOG_INTERVAL_MILLIS) {
        Log.getLogWriter()
            .info("Verified key " + verifyRegionContentsIndex + " out of " + totalNumKeys);
        lastLogTime = System.currentTimeMillis();
      }

      if (System.currentTimeMillis() - startTime >= minTaskGranularityMS) {
        Log.getLogWriter()
            .info(
                "In HydraTask_verifyRegionContents, returning before completing verify "
                    + "because of task granularity (this task must be batched to complete); last key verified is "
                    + key);
        return; // task is batched; we are done with this batch
      }
    }
    verifyRegionContentsCompleted = true;
    if (verifyRegionContentsErrStr.length() > 0) {
      throw new TestException(verifyRegionContentsErrStr.toString());
    }
    String aStr =
        "In HydraTask_verifyRegionContents, verified " + verifyRegionContentsIndex + " keys/values";
    Log.getLogWriter().info(aStr);
    throw new StopSchedulingTaskOnClientOrder(aStr);
  }
  /**
   * check distributed ops that originate in a PROXY are correctly distributed to non-proxy regions.
   */
  private void distributedOps(DataPolicy dp, InterestPolicy ip) throws CacheException {
    initOtherId();
    AttributesFactory af = new AttributesFactory();
    af.setDataPolicy(dp);
    af.setSubscriptionAttributes(new SubscriptionAttributes(ip));
    af.setScope(Scope.DISTRIBUTED_ACK);
    Region r = createRootRegion("ProxyDUnitTest", af.create());

    doCreateOtherVm();

    r.put("putkey", "putvalue1");

    getOtherVm()
        .invoke(
            new CacheSerializableRunnable("check put") {
              public void run2() throws CacheException {
                Region r = getRootRegion("ProxyDUnitTest");
                assertEquals(true, r.containsKey("putkey"));
                assertEquals("putvalue1", r.getEntry("putkey").getValue());
                r.put("putkey", "putvalue2");
              }
            });

    assertEquals(false, r.containsKey("putkey"));
    assertEquals("putvalue2", r.get("putkey")); // netsearch

    r.invalidate("putkey");

    getOtherVm()
        .invoke(
            new CacheSerializableRunnable("check invalidate") {
              public void run2() throws CacheException {
                Region r = getRootRegion("ProxyDUnitTest");
                assertEquals(true, r.containsKey("putkey"));
                assertEquals(null, r.getEntry("putkey").getValue());
              }
            });
    assertEquals(null, r.get("putkey")); // invalid so total miss

    r.destroy("putkey");

    getOtherVm()
        .invoke(
            new CacheSerializableRunnable("check destroy") {
              public void run2() throws CacheException {
                Region r = getRootRegion("ProxyDUnitTest");
                assertEquals(false, r.containsKey("putkey"));
              }
            });

    assertEquals(null, r.get("putkey")); // total miss

    r.create("createKey", "createValue1");
    getOtherVm()
        .invoke(
            new CacheSerializableRunnable("check create") {
              public void run2() throws CacheException {
                Region r = getRootRegion("ProxyDUnitTest");
                assertEquals(true, r.containsKey("createKey"));
                assertEquals("createValue1", r.getEntry("createKey").getValue());
              }
            });
    {
      Map m = new HashMap();
      m.put("putAllKey1", "putAllValue1");
      m.put("putAllKey2", "putAllValue2");
      r.putAll(m, "putAllCallback");
    }
    getOtherVm()
        .invoke(
            new CacheSerializableRunnable("check putAll") {
              public void run2() throws CacheException {
                Region r = getRootRegion("ProxyDUnitTest");
                assertEquals(true, r.containsKey("putAllKey1"));
                assertEquals("putAllValue1", r.getEntry("putAllKey1").getValue());
                assertEquals(true, r.containsKey("putAllKey2"));
                assertEquals("putAllValue2", r.getEntry("putAllKey2").getValue());
              }
            });
    r.clear();
    getOtherVm()
        .invoke(
            new CacheSerializableRunnable("check clear") {
              public void run2() throws CacheException {
                Region r = getRootRegion("ProxyDUnitTest");
                assertEquals(0, r.size());
              }
            });

    getOtherVm()
        .invoke(
            new CacheSerializableRunnable("install CacheWriter") {
              public void run2() throws CacheException {
                Region r = getRootRegion("ProxyDUnitTest");
                AttributesMutator am = r.getAttributesMutator();
                CacheWriter cw =
                    new CacheWriterAdapter() {
                      public void beforeCreate(EntryEvent event) throws CacheWriterException {
                        throw new CacheWriterException("expected");
                      }
                    };
                am.setCacheWriter(cw);
              }
            });
    try {
      r.put("putkey", "putvalue");
      fail("expected CacheWriterException");
    } catch (CacheWriterException expected) {
    }
    getOtherVm()
        .invoke(
            new CacheSerializableRunnable("check clear") {
              public void run2() throws CacheException {
                Region r = getRootRegion("ProxyDUnitTest");
                assertEquals(0, r.size());
              }
            });

    assertEquals(null, r.get("loadkey")); // total miss
    getOtherVm()
        .invoke(
            new CacheSerializableRunnable("install CacheLoader") {
              public void run2() throws CacheException {
                Region r = getRootRegion("ProxyDUnitTest");
                AttributesMutator am = r.getAttributesMutator();
                am.setCacheWriter(null); // clear csche writer
                CacheLoader cl =
                    new CacheLoader() {
                      public Object load(LoaderHelper helper) throws CacheLoaderException {
                        if (helper.getKey().equals("loadkey")) {
                          return "loadvalue";
                        } else if (helper.getKey().equals("loadexception")) {
                          throw new CacheLoaderException("expected");
                        } else {
                          return null;
                        }
                      }

                      public void close() {}
                    };
                am.setCacheLoader(cl);
              }
            });
    assertEquals("loadvalue", r.get("loadkey")); // net load
    assertEquals(null, r.get("foobar")); // total miss
    try {
      r.get("loadexception");
      fail("expected CacheLoaderException");
    } catch (CacheLoaderException expected) {
    }
    r.destroyRegion();
    getOtherVm()
        .invoke(
            new CacheSerializableRunnable("check clear") {
              public void run2() throws CacheException {
                Region r = getRootRegion("ProxyDUnitTest");
                assertEquals(null, r);
              }
            });
  }
  @SuppressWarnings({"rawtypes", "unchecked"})
  private void doRegionTest(final RegionShortcut rs, final String rName, boolean compressed) {
    boolean isPersistent =
        rs == RegionShortcut.LOCAL_PERSISTENT
            || rs == RegionShortcut.REPLICATE_PERSISTENT
            || rs == RegionShortcut.PARTITION_PERSISTENT;
    GemFireCacheImpl gfc = createCache(isPersistent);
    Region r = null;
    try {
      gfc.setCopyOnRead(true);
      final MemoryAllocator ma = gfc.getOffHeapStore();
      assertNotNull(ma);
      assertEquals(0, ma.getUsedMemory());
      Compressor compressor = null;
      if (compressed) {
        compressor = SnappyCompressor.getDefaultInstance();
      }
      r = gfc.createRegionFactory(rs).setOffHeap(true).setCompressor(compressor).create(rName);
      assertEquals(true, r.isEmpty());
      assertEquals(0, ma.getUsedMemory());
      Object data = new Integer(123456789);
      r.put("key1", data);
      // System.out.println("After put of Integer value off heap used memory=" +
      // ma.getUsedMemory());
      assertTrue(ma.getUsedMemory() == 0);
      assertEquals(data, r.get("key1"));
      r.invalidate("key1");
      assertEquals(0, ma.getUsedMemory());
      r.put("key1", data);
      assertTrue(ma.getUsedMemory() == 0);
      long usedBeforeUpdate = ma.getUsedMemory();
      r.put("key1", data);
      assertEquals(usedBeforeUpdate, ma.getUsedMemory());
      assertEquals(data, r.get("key1"));
      r.destroy("key1");
      assertEquals(0, ma.getUsedMemory());

      data = new Long(0x007FFFFFL);
      r.put("key1", data);
      if (!compressed) {
        assertTrue(ma.getUsedMemory() == 0);
      }
      assertEquals(data, r.get("key1"));
      data = new Long(0xFF8000000L);
      r.put("key1", data);
      if (!compressed) {
        assertTrue(ma.getUsedMemory() == 0);
      }
      assertEquals(data, r.get("key1"));

      // now lets set data to something that will be stored offheap
      data = new Long(Long.MAX_VALUE);
      r.put("key1", data);
      assertEquals(data, r.get("key1"));
      // System.out.println("After put of Integer value off heap used memory=" +
      // ma.getUsedMemory());
      assertTrue(ma.getUsedMemory() > 0);
      data = new Long(Long.MIN_VALUE);
      r.put("key1", data);
      assertEquals(data, r.get("key1"));
      // System.out.println("After put of Integer value off heap used memory=" +
      // ma.getUsedMemory());
      assertTrue(ma.getUsedMemory() > 0);
      r.invalidate("key1");
      assertEquals(0, ma.getUsedMemory());
      r.put("key1", data);
      assertTrue(ma.getUsedMemory() > 0);
      usedBeforeUpdate = ma.getUsedMemory();
      r.put("key1", data);
      assertEquals(usedBeforeUpdate, ma.getUsedMemory());
      assertEquals(data, r.get("key1"));
      r.destroy("key1");
      assertEquals(0, ma.getUsedMemory());

      // confirm that byte[] do use off heap
      {
        byte[] originalBytes = new byte[1024];
        Object oldV = r.put("byteArray", originalBytes);
        long startUsedMemory = ma.getUsedMemory();
        assertEquals(null, oldV);
        byte[] readBytes = (byte[]) r.get("byteArray");
        if (originalBytes == readBytes) {
          fail("Expected different byte[] identity");
        }
        if (!Arrays.equals(readBytes, originalBytes)) {
          fail("Expected byte array contents to be equal");
        }
        assertEquals(startUsedMemory, ma.getUsedMemory());
        oldV = r.put("byteArray", originalBytes);
        if (!compressed) {
          assertEquals(null, oldV); // we default to old value being null for offheap
        }
        assertEquals(startUsedMemory, ma.getUsedMemory());

        readBytes = (byte[]) r.putIfAbsent("byteArray", originalBytes);
        if (originalBytes == readBytes) {
          fail("Expected different byte[] identity");
        }
        if (!Arrays.equals(readBytes, originalBytes)) {
          fail("Expected byte array contents to be equal");
        }
        assertEquals(startUsedMemory, ma.getUsedMemory());
        if (!r.replace("byteArray", readBytes, originalBytes)) {
          fail("Expected replace to happen");
        }
        assertEquals(startUsedMemory, ma.getUsedMemory());
        byte[] otherBytes = new byte[1024];
        otherBytes[1023] = 1;
        if (r.replace("byteArray", otherBytes, originalBytes)) {
          fail("Expected replace to not happen");
        }
        if (r.replace("byteArray", "bogus string", originalBytes)) {
          fail("Expected replace to not happen");
        }
        if (r.remove("byteArray", "bogus string")) {
          fail("Expected remove to not happen");
        }
        assertEquals(startUsedMemory, ma.getUsedMemory());

        if (!r.remove("byteArray", originalBytes)) {
          fail("Expected remove to happen");
        }
        assertEquals(0, ma.getUsedMemory());
        oldV = r.putIfAbsent("byteArray", "string value");
        assertEquals(null, oldV);
        assertEquals("string value", r.get("byteArray"));
        if (r.replace("byteArray", "string valuE", originalBytes)) {
          fail("Expected replace to not happen");
        }
        if (!r.replace("byteArray", "string value", originalBytes)) {
          fail("Expected replace to happen");
        }
        oldV = r.destroy("byteArray"); // we default to old value being null for offheap
        if (!compressed) {
          assertEquals(null, oldV);
        }
        MyCacheListener listener = new MyCacheListener();
        r.getAttributesMutator().addCacheListener(listener);
        try {
          Object valueToReplace = "string value1";
          r.put("byteArray", valueToReplace);
          assertEquals(null, listener.ohOldValue);
          if (!compressed) {
            assertEquals("string value1", listener.ohNewValue.getDeserializedForReading());
            valueToReplace = listener.ohNewValue;
          }
          if (!r.replace("byteArray", valueToReplace, "string value2")) {
            fail("expected replace to happen");
          }
          if (!compressed) {
            assertEquals("string value2", listener.ohNewValue.getDeserializedForReading());
            assertEquals("string value1", listener.ohOldValue.getDeserializedForReading());
          }
          // make sure that a custom equals/hashCode are not used when comparing values.

        } finally {
          r.getAttributesMutator().removeCacheListener(listener);
        }
      }
      assertTrue(ma.getUsedMemory() > 0);
      {
        Object key = "MyValueWithPartialEquals";
        MyValueWithPartialEquals v1 = new MyValueWithPartialEquals("s1");
        MyValueWithPartialEquals v2 = new MyValueWithPartialEquals("s2");
        MyValueWithPartialEquals v3 = new MyValueWithPartialEquals("s1");
        r.put(key, v1);
        try {
          if (r.replace(key, v2, "should not happen")) {
            fail("v1 should not be equal to v2 on an offheap region");
          }
          if (!r.replace(key, v3, "should happen")) {
            fail("v1 should be equal to v3 on an offheap region");
          }
          r.put(key, v1);
          if (r.remove(key, v2)) {
            fail("v1 should not be equal to v2 on an offheap region");
          }
          if (!r.remove(key, v3)) {
            fail("v1 should be equal to v3 on an offheap region");
          }
        } finally {
          r.remove(key);
        }
      }
      {
        Object key = "MyPdxWithPartialEquals";
        MyPdxWithPartialEquals v1 = new MyPdxWithPartialEquals("s", "1");
        MyPdxWithPartialEquals v2 = new MyPdxWithPartialEquals("s", "2");
        MyPdxWithPartialEquals v3 = new MyPdxWithPartialEquals("t", "1");
        r.put(key, v1);
        try {
          if (r.replace(key, v3, "should not happen")) {
            fail("v1 should not be equal to v3 on an offheap region");
          }
          if (!r.replace(key, v2, "should happen")) {
            fail("v1 should be equal to v2 on an offheap region");
          }
          r.put(key, v1);
          if (r.remove(key, v3)) {
            fail("v1 should not be equal to v3 on an offheap region");
          }
          if (!r.remove(key, v2)) {
            fail("v1 should be equal to v2 on an offheap region");
          }
        } finally {
          r.remove(key);
        }
      }
      byte[] value = new byte[1024];
      /*while (value != null) */ {
        r.put("byteArray", value);
      }
      r.remove("byteArray");
      assertEquals(0, ma.getUsedMemory());

      r.put("key1", data);
      assertTrue(ma.getUsedMemory() > 0);
      r.invalidateRegion();
      assertEquals(0, ma.getUsedMemory());

      r.put("key1", data);
      assertTrue(ma.getUsedMemory() > 0);
      try {
        r.clear();
        assertEquals(0, ma.getUsedMemory());
      } catch (UnsupportedOperationException ok) {
      }

      r.put("key1", data);
      assertTrue(ma.getUsedMemory() > 0);
      if (r.getAttributes().getDataPolicy().withPersistence()) {
        r.put("key2", Integer.valueOf(1234567890));
        r.put("key3", new Long(0x007FFFFFL));
        r.put("key4", new Long(0xFF8000000L));
        assertEquals(4, r.size());
        r.close();
        assertEquals(0, ma.getUsedMemory());
        // simple test of recovery
        r = gfc.createRegionFactory(rs).setOffHeap(true).create(rName);
        assertEquals(4, r.size());
        assertEquals(data, r.get("key1"));
        assertEquals(Integer.valueOf(1234567890), r.get("key2"));
        assertEquals(new Long(0x007FFFFFL), r.get("key3"));
        assertEquals(new Long(0xFF8000000L), r.get("key4"));
        closeCache(gfc, true);
        assertEquals(0, ma.getUsedMemory());
        gfc = createCache();
        if (ma != gfc.getOffHeapStore()) {
          fail("identity of offHeapStore changed when cache was recreated");
        }
        r = gfc.createRegionFactory(rs).setOffHeap(true).create(rName);
        assertTrue(ma.getUsedMemory() > 0);
        assertEquals(4, r.size());
        assertEquals(data, r.get("key1"));
        assertEquals(Integer.valueOf(1234567890), r.get("key2"));
        assertEquals(new Long(0x007FFFFFL), r.get("key3"));
        assertEquals(new Long(0xFF8000000L), r.get("key4"));
      }

      r.destroyRegion();
      assertEquals(0, ma.getUsedMemory());

    } finally {
      if (r != null && !r.isDestroyed()) {
        r.destroyRegion();
      }
      closeCache(gfc, false);
    }
  }
  private ByteBuffer processBinaryProtocol(RequestReader request, Cache cache) {
    ByteBuffer buffer = request.getRequest();
    int extrasLength = buffer.get(EXTRAS_LENGTH_INDEX);
    final KeyWrapper key = getKey(buffer, HEADER_LENGTH + extrasLength);

    long decrBy = buffer.getLong(HEADER_LENGTH);
    long initialVal = buffer.getLong(HEADER_LENGTH + LONG_LENGTH);
    int expiration = buffer.getInt(HEADER_LENGTH + LONG_LENGTH + LONG_LENGTH);

    final Region<Object, ValueWrapper> r = getMemcachedRegion(cache);
    ByteBuffer newVal = ByteBuffer.allocate(8);
    boolean notFound = false;
    ValueWrapper newValWrapper = null;

    try {
      while (true) {
        ValueWrapper oldValWrapper = r.get(key);
        if (oldValWrapper == null) {
          if (expiration == -1) {
            notFound = true;
          } else {
            newVal.putLong(0, initialVal);
            newValWrapper = ValueWrapper.getWrappedValue(newVal.array(), 0 /*flags*/);
            r.put(key, newValWrapper);
          }
          break;
        }
        byte[] oldVal = oldValWrapper.getValue();
        long oldLong = getLongFromByteArray(oldVal);
        long newLong = oldLong - decrBy;
        if (newLong < 0) {
          newLong = 0;
        }
        newVal.putLong(0, newLong);
        newValWrapper = ValueWrapper.getWrappedValue(newVal.array(), 0 /*flags*/);
        if (r.replace(key, oldValWrapper, newValWrapper)) {
          break;
        }
      }
    } catch (Exception e) {
      return handleBinaryException(key, request, request.getResponse(), "decrement", e);
    }

    if (expiration > 0) {
      StorageCommand.getExpiryExecutor()
          .schedule(
              new Runnable() {
                @Override
                public void run() {
                  r.destroy(key);
                }
              },
              expiration,
              TimeUnit.SECONDS);
    }

    if (getLogger().fineEnabled()) {
      getLogger()
          .fine(
              "decr:key:"
                  + key
                  + " decrBy:"
                  + decrBy
                  + " initVal:"
                  + initialVal
                  + " exp:"
                  + expiration
                  + " notFound:"
                  + notFound);
    }

    ByteBuffer response = null;
    if (notFound) {
      response = request.getResponse();
      response.putShort(POSITION_RESPONSE_STATUS, ResponseStatus.KEY_NOT_FOUND.asShort());
    } else {
      if (isQuiet()) {
        return null;
      }
      response = request.getResponse(HEADER_LENGTH + LONG_LENGTH);
      response.putInt(TOTAL_BODY_LENGTH_INDEX, LONG_LENGTH);
      response.putLong(HEADER_LENGTH, newVal.getLong(0));
      response.putLong(POSITION_CAS, newValWrapper.getVersion());
    }
    return response;
  }