/*
* Copyright 2015 Martin Bella
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.orange_box.storebox.harness.changes;
import android.test.UiThreadTest;
import android.test.suitebuilder.annotation.SmallTest;
import net.orange_box.storebox.harness.base.PreferencesTestCase;
import net.orange_box.storebox.harness.interfaces.changes.ChangeListenersInterface;
import net.orange_box.storebox.harness.types.CustomClass;
import net.orange_box.storebox.listeners.OnPreferenceValueChangedListener;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
public class ChangesListenersTestCase extends
PreferencesTestCase<ChangeListenersInterface> {
@Override
protected Class<ChangeListenersInterface> getInterface() {
return ChangeListenersInterface.class;
}
@UiThreadTest
@SmallTest
public void testIntChanged() {
final AtomicInteger value = new AtomicInteger(-1);
final OnPreferenceValueChangedListener<Integer> listener =
new OnPreferenceValueChangedListener<Integer>() {
@Override
public void onChanged(Integer newValue) {
value.set(newValue);
}
};
uut.registerIntChangeListener(listener);
uut.setInt(1);
assertEquals(1, value.get());
}
@UiThreadTest
@SmallTest
public void testIntChangedMultiple() {
final AtomicInteger count = new AtomicInteger(2);
final OnPreferenceValueChangedListener<Integer> one =
new OnPreferenceValueChangedListener<Integer>() {
@Override
public void onChanged(Integer newValue) {
assertEquals(1, newValue.intValue());
count.decrementAndGet();
}
};
final OnPreferenceValueChangedListener<Integer> two =
new OnPreferenceValueChangedListener<Integer>() {
@Override
public void onChanged(Integer newValue) {
assertEquals(1, newValue.intValue());
count.decrementAndGet();
}
};
uut.registerIntChangeListener(one);
uut.registerIntChangeListener(two);
uut.setInt(1);
assertEquals(0, count.get());
}
@UiThreadTest
@SmallTest
public void testIntChangedVarArgs() {
final AtomicInteger count = new AtomicInteger(2);
final OnPreferenceValueChangedListener<Integer> one =
new OnPreferenceValueChangedListener<Integer>() {
@Override
public void onChanged(Integer newValue) {
assertEquals(1, newValue.intValue());
count.decrementAndGet();
}
};
final OnPreferenceValueChangedListener<Integer> two =
new OnPreferenceValueChangedListener<Integer>() {
@Override
public void onChanged(Integer newValue) {
assertEquals(1, newValue.intValue());
count.decrementAndGet();
}
};
uut.registerIntChangeListenerVarArgs(one, two);
uut.setInt(1);
assertEquals(0, count.get());
}
@UiThreadTest
@SmallTest
public void testIntUnregistered() {
final AtomicBoolean called = new AtomicBoolean();
final OnPreferenceValueChangedListener<Integer> listener =
new OnPreferenceValueChangedListener<Integer>() {
@Override
public void onChanged(Integer newValue) {
called.set(true);
}
};
uut.registerIntChangeListener(listener);
uut.unregisterIntChangeListener(listener);
uut.setInt(1);
assertFalse(called.get());
}
@UiThreadTest
@SmallTest
public void testIntUnregisteredVarArgs() {
final AtomicInteger count = new AtomicInteger(2);
final OnPreferenceValueChangedListener<Integer> one =
new OnPreferenceValueChangedListener<Integer>() {
@Override
public void onChanged(Integer newValue) {
count.decrementAndGet();
}
};
final OnPreferenceValueChangedListener<Integer> two =
new OnPreferenceValueChangedListener<Integer>() {
@Override
public void onChanged(Integer newValue) {
count.decrementAndGet();
}
};
uut.registerIntChangeListenerVarArgs(one, two);
uut.unregisterIntChangeListenerVarArgs(one, two);
uut.setInt(1);
assertEquals(2, count.get());
}
@UiThreadTest
@SmallTest
public void testCustomClassChanged() {
final AtomicReference<CustomClass> value = new AtomicReference<>();
final OnPreferenceValueChangedListener<CustomClass> listener =
new OnPreferenceValueChangedListener<CustomClass>() {
@Override
public void onChanged(CustomClass newValue) {
value.set(newValue);
}
};
uut.registerCustomClassChangeListener(listener);
uut.setCustomClass(new CustomClass("a", "b"));
assertEquals(new CustomClass("a", "b"), value.get());
}
@UiThreadTest
@SmallTest
public void testCustomClassChangedNull() {
final AtomicReference<CustomClass> value = new AtomicReference<>();
final OnPreferenceValueChangedListener<CustomClass> listener =
new OnPreferenceValueChangedListener<CustomClass>() {
@Override
public void onChanged(CustomClass newValue) {
value.set(newValue);
}
};
uut.setCustomClass(new CustomClass("a", "b"));
uut.registerCustomClassChangeListener(listener);
uut.setCustomClass(null);
assertNull(value.get());
}
@UiThreadTest
@SmallTest
public void testCustomClassChangedMultiple() {
final AtomicInteger count = new AtomicInteger(2);
final OnPreferenceValueChangedListener<CustomClass> one =
new OnPreferenceValueChangedListener<CustomClass>() {
@Override
public void onChanged(CustomClass newValue) {
assertEquals(new CustomClass("a", "b"), newValue);
count.decrementAndGet();
}
};
final OnPreferenceValueChangedListener<CustomClass> two =
new OnPreferenceValueChangedListener<CustomClass>() {
@Override
public void onChanged(CustomClass newValue) {
assertEquals(new CustomClass("a", "b"), newValue);
count.decrementAndGet();
}
};
uut.registerCustomClassChangeListener(one);
uut.registerCustomClassChangeListener(two);
uut.setCustomClass(new CustomClass("a", "b"));
assertEquals(0, count.get());
}
@UiThreadTest
@SmallTest
public void testCustomClassUnregistered() {
final AtomicBoolean called = new AtomicBoolean();
final OnPreferenceValueChangedListener<CustomClass> listener =
new OnPreferenceValueChangedListener<CustomClass>() {
@Override
public void onChanged(CustomClass newValue) {
called.set(true);
}
};
uut.registerCustomClassChangeListener(listener);
uut.unregisterCustomClassChangeListener(listener);
uut.setCustomClass(new CustomClass("a", "b"));
assertFalse(called.get());
}
@UiThreadTest
@SmallTest
public void testListenerGarbageCollected() throws Exception {
final AtomicBoolean called = new AtomicBoolean();
uut.registerIntChangeListener(new OnPreferenceValueChangedListener<Integer>() {
@Override
public void onChanged(Integer newValue) {
called.set(true);
}
});
// nasty, but it does force collection of soft references...
// TODO is there a better way to do this?
try {
Object[] ignored = new Object[(int) Runtime.getRuntime().maxMemory()];
} catch (OutOfMemoryError e) {
// NOP
}
uut.setInt(1);
assertFalse(called.get());
}
}
