Extending object's life in cache api - expireAt api date - timestamp parameter error

When we use the expireAt API call below we always get the following error:
BackendlessException{ code: ‘1031’、 message: ‘Timestamp should be after current date’ }

Android SDK version : Backendless SDK v1.10 for Android, released 08.11.2014.

    public boolean utilitiesCachingSync() {
        mRet = false;


        Thread thread = new Thread(new Runnable() {


            @Override
            public void run() {
                try {
                    final String UNITTEST_KEY = "unittestkey";
                    final String UNITTEST_OBJ = "unitteststring";


                    Backendless.Cache.put(UNITTEST_KEY, UNITTEST_OBJ);
                    Calendar calendar = Calendar.getInstance(Locale.US);
                    calendar.add(Calendar.SECOND, 2);
                    Date expiration = calendar.getTime();
                    Backendless.Cache.expireAt(UNITTEST_KEY, expiration);
                    Thread.sleep(4000);
                    if(Backendless.Cache.contains(UNITTEST_KEY) == true) {
                        mRet = false;
                        return;
                    }


                    Backendless.Cache.put(UNITTEST_KEY, UNITTEST_OBJ);
                    Calendar calendar2 = Calendar.getInstance(Locale.US);
                    calendar2.add(Calendar.SECOND, 2);
                    Date expiration2 = calendar2.getTime();
                    Backendless.Cache.expireAt(UNITTEST_KEY, expiration2.getTime());
                    Thread.sleep(4000);
                    if(Backendless.Cache.contains(UNITTEST_KEY) == true) {
                        mRet = false;
                        return;
                    }


                    mRet = true;


                } catch (Exception e) {
                    Log.e(TAG, e.toString());
                    mRet = false;
                }
            }


        });
        try {
            thread.start();
            thread.join();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return mRet;
    }
    public boolean utilitiesCachingAsync() {
        mRet = false;


        Thread thread = new Thread(new Runnable() {


            @Override
            public void run() {
                try {
                    final String UNITTEST_KEY = "unittestkey";
                    final String UNITTEST_OBJ = "unitteststring";


                    Backendless.Cache.put(UNITTEST_KEY, UNITTEST_OBJ);
                    Calendar calendar = Calendar.getInstance(Locale.US);
                    calendar.add(Calendar.SECOND, 2);
                    Date expiration = calendar.getTime();


                    final CountDownLatch signal11 = new CountDownLatch(1);
                    Backendless.Cache.expireAt(UNITTEST_KEY, expiration, new AsyncCallback<Object>() {


                        @Override
                        public void handleResponse(Object o) {
                            mRet = true;
                            signal11.countDown();
                        }


                        @Override
                        public void handleFault(BackendlessFault fault) {
                            Log.e(TAG, fault.toString());
                            mRet = false;
                            signal11.countDown();
                        }
                    });
                    try {
                        signal11.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if(mRet == false)
                        return;
                    mRet = false;


                    Thread.sleep(4000);


                    final CountDownLatch signal12 = new CountDownLatch(1);
                    Backendless.Cache.contains(UNITTEST_KEY, new AsyncCallback<Boolean>() {


                        @Override
                        public void handleResponse(Boolean result) {
                            if(result == true)
                                mRet = false;
                            else
                                mRet = true;
                            signal12.countDown();
                        }


                        @Override
                        public void handleFault(BackendlessFault fault) {
                            Log.e(TAG, fault.toString());
                            mRet = false;
                            signal12.countDown();
                        }
                    });
                    try {
                        signal12.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if(mRet == false)
                        return;
                    mRet = false;


                    Backendless.Cache.put(UNITTEST_KEY, UNITTEST_OBJ);
                    Calendar calendar2 = Calendar.getInstance(Locale.US);
                    calendar2.add(Calendar.SECOND, 2);
                    Date expiration2 = calendar2.getTime();


                    final CountDownLatch signal13 = new CountDownLatch(1);
                    Backendless.Cache.expireAt(UNITTEST_KEY, expiration2.getTime(), new AsyncCallback<Object>() {


                        @Override
                        public void handleResponse(Object o) {
                            mRet = true;
                            signal13.countDown();
                        }


                        @Override
                        public void handleFault(BackendlessFault fault) {
                            Log.e(TAG, fault.toString());
                            mRet = false;
                            signal13.countDown();
                        }
                    });
                    try {
                        signal13.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if(mRet == false)
                        return;
                    mRet = false;


                    Thread.sleep(4000);


                    final CountDownLatch signal14 = new CountDownLatch(1);
                    Backendless.Cache.contains(UNITTEST_KEY, new AsyncCallback<Boolean>() {


                        @Override
                        public void handleResponse(Boolean result) {
                            if(result == true)
                                mRet = false;
                            else
                                mRet = true;
                            signal14.countDown();
                        }


                        @Override
                        public void handleFault(BackendlessFault fault) {
                            Log.e(TAG, fault.toString());
                            mRet = false;
                            signal14.countDown();
                        }
                    });
                    try {
                        signal14.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if(mRet == false)
                        return;


                    mRet = true;


                } catch (Exception e) {
                    Log.e(TAG, e.toString());
                    mRet = false;
                }
            }


        });
        try {
            thread.start();
            thread.join();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return mRet;
    }