Fixed NPE when removeCallbacks() called concurrently

Author: Dmytro Voronkevych

build.gradle

@@ -18,35 +18,45 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
-project.ext.set('VERSION_CODE', 1)
-project.ext.set('VERSION_NAME', '1.0')
+project.ext.set('VERSION_CODE', 2)
+project.ext.set('VERSION_NAME', '1.1')
 
 buildscript {
     repositories {
         mavenCentral()
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:0.12.+'
+        classpath 'com.android.tools.build:gradle:1.2.3'
     }
 }
 
 apply plugin: 'com.android.library'
 
+repositories {
+    mavenCentral()
+}
+
 dependencies {
-    compile "com.android.support:support-annotations:19.1.0"
+    compile "com.android.support:support-annotations:22.2.0"
+    androidTestCompile 'junit:junit:4.12'
+    androidTestCompile('com.android.support.test:runner:0.2') {
+        exclude group: 'junit'
+    }
 }
 
 
 android {
-    compileSdkVersion 19
-    buildToolsVersion "19.1.0"
+    compileSdkVersion 22
+    buildToolsVersion "22.0.1"
 
     defaultConfig {
         versionCode project.VERSION_CODE
         versionName project.VERSION_NAME
         minSdkVersion 8
-        targetSdkVersion 19
+        targetSdkVersion 22
+
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
     }
 }
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Wed Aug 27 15:30:55 BST 2014
+#Tue Jun 02 19:11:40 BST 2015
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-1.11-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.2.1-all.zip

src/androidTest/java/com/badoo/mobile/util/WeakHandlerChainedRefTest.java

@@ -0,0 +1,135 @@
+package com.badoo.mobile.util;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+import static junit.framework.Assert.assertNull;
+import static junit.framework.Assert.assertSame;
+
+/**
+ * Tests for {@link com.badoo.mobile.util.WeakHandler.ChainedRef}
+ *
+ * @author Dmytro Voronkevych
+ */
+@SuppressWarnings("ALL")
+@SmallTest
+@RunWith(AndroidJUnit4.class)
+public class WeakHandlerChainedRefTest {
+
+    private Runnable mHeadRunnable;
+    private Runnable mFirstRunnable;
+    private Runnable mSecondRunnable;
+    private Lock mLock;
+    private WeakHandler.ChainedRef mRefHead;
+    private WeakHandler.ChainedRef mFirst;
+    private WeakHandler.ChainedRef mSecond;
+    private WeakHandler.WeakRunnable mHeadWeakRunnable;
+    private WeakHandler.WeakRunnable mFirstWeakRunnable;
+    private WeakHandler.WeakRunnable mSecondWeakRunnable;
+
+    @Before
+    public void setUp() {
+        mLock = new ReentrantLock();
+
+        mHeadRunnable = new DummyRunnable();
+        mFirstRunnable = new DummyRunnable();
+        mSecondRunnable = new DummyRunnable();
+
+        mRefHead = new WeakHandler.ChainedRef(mLock, mHeadRunnable) {
+            @Override
+            public String toString() {
+                return "refHead";
+            }
+        };
+        mFirst = new WeakHandler.ChainedRef(mLock, mFirstRunnable) {
+            @Override
+            public String toString() {
+                return "first";
+            }
+        };
+        mSecond = new WeakHandler.ChainedRef(mLock, mSecondRunnable) {
+            @Override
+            public String toString() {
+                return "second";
+            }
+        };
+
+        mRefHead.insertAbove(mFirst);
+        mRefHead.insertAbove(mSecond);
+
+        mHeadWeakRunnable = mRefHead.wrapper;
+        mFirstWeakRunnable = mFirst.wrapper;
+        mSecondWeakRunnable = mSecond.wrapper;
+    }
+
+    @Test
+    public void insertAbove() {
+        assertSame(mSecond, mRefHead.next);
+        assertSame(mFirst, mRefHead.next.next);
+        assertNull(mRefHead.next.next.next);
+
+        assertNull(mRefHead.prev);
+        assertSame(mSecond, mFirst.prev);
+        assertSame(mRefHead, mSecond.prev);
+    }
+
+    @Test
+    public void removeFirst() {
+        mFirst.remove();
+        assertNull(mFirst.next);
+        assertNull(mFirst.prev);
+
+        assertSame(mSecond, mRefHead.next);
+        assertSame(mRefHead, mSecond.prev);
+        assertNull(mSecond.next);
+    }
+
+    @Test
+    public void removeSecond() {
+        mSecond.remove();
+
+        assertNull(mSecond.next);
+        assertNull(mSecond.prev);
+
+        assertSame(mFirst, mRefHead.next);
+        assertNull(mFirst.next);
+        assertSame(mRefHead, mFirst.prev);
+    }
+
+    @Test
+    public void removeFirstByRunnable() {
+        assertSame(mFirstWeakRunnable, mRefHead.remove(mFirstRunnable));
+        assertSame(mRefHead.next, mSecond);
+        assertSame(mRefHead, mSecond.prev);
+        assertNull(mSecond.next);
+    }
+
+    @Test
+    public void removeSecondByRunnable() {
+        assertSame(mSecondWeakRunnable, mRefHead.remove(mSecondRunnable));
+        assertSame(mFirst, mRefHead.next);
+        assertSame(mRefHead, mFirst.prev);
+    }
+
+    @Test
+    public void removeUnexistentRunnableReturnNull() {
+        assertNull(mRefHead.remove(new DummyRunnable()));
+        assertSame(mSecond, mRefHead.next);
+        assertNull(mFirst.next);
+        assertSame(mSecond, mFirst.prev);
+        assertSame(mRefHead, mSecond.prev);
+    }
+
+    private class DummyRunnable implements Runnable {
+        @Override
+        public void run() {
+        }
+    }
+}