@Test
public void testClear() throws Exception {
// given
prefser.clear();
prefser.put("key1", 1);
prefser.put("key2", 2);
prefser.put("key3", 3);
// when
assertThat(prefser.size()).isEqualTo(3);
prefser.clear();
// then
assertThat(prefser.size()).isEqualTo(0);
}
@Test
public void testPutArrayOfCustomObjects() {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
CustomClass defaultCustomObject = new CustomClass(1, "");
CustomClass[] customClassesArray =
new CustomClass[] {
new CustomClass(1, "first"), new CustomClass(2, "second"), new CustomClass(3, "third")
};
CustomClass[] defaultCustomClassesArray =
new CustomClass[] {defaultCustomObject, defaultCustomObject, defaultCustomObject};
// when
prefser.put(givenKey, customClassesArray);
CustomClass[] readObject =
prefser.get(givenKey, CustomClass[].class, defaultCustomClassesArray);
// then
assertThat(readObject[0]).isEqualTo(customClassesArray[0]);
assertThat(readObject[1]).isEqualTo(customClassesArray[1]);
assertThat(readObject[2]).isEqualTo(customClassesArray[2]);
prefser.remove(givenKey);
}
@Test
public void testSize() throws Exception {
// given
prefser.clear();
String keyToRemove = "key1";
// when
prefser.put(keyToRemove, 1);
prefser.put("key2", 2);
prefser.put("key3", 3);
// then
assertThat(prefser.size()).isEqualTo(3);
prefser.remove(keyToRemove);
assertThat(prefser.size()).isEqualTo(2);
prefser.clear();
assertThat(prefser.size()).isEqualTo(0);
}
@Test(expected = NullPointerException.class)
public void testPutShouldThrowAnExceptionWhenKeyAndValueAreNullForPut() {
// given
String key = null;
String value = null;
// when
prefser.put(key, value);
// then
// throw an exception
}
@Test
public void testRemove() throws Exception {
// given
String givenKey = GIVEN_KEY;
prefser.put(givenKey, 1);
// when
assertThat(prefser.contains(givenKey)).isTrue();
prefser.remove(givenKey);
// then
assertThat(prefser.contains(givenKey)).isFalse();
}
@Test(expected = NullPointerException.class)
public void testShouldThrowAnExceptionWhenClassOfTForGetIsNull() {
// given
String key = GIVEN_KEY;
Class classOfT = null;
prefser.put(key, GIVEN_STRING_VALUE);
// when
prefser.get(key, classOfT, "");
// then
// throw an exception
}
@Test
public void testContains() throws Exception {
// given
prefser.clear();
String givenValue = GIVEN_STRING_VALUE;
String givenKey = GIVEN_KEY;
// when
prefser.put(givenKey, givenValue);
// then
assertThat(prefser.contains(givenKey)).isTrue();
prefser.remove(givenKey);
assertThat(prefser.contains(givenKey)).isFalse();
}
@Test
public void testPutCustomObject() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
CustomClass givenObject = new CustomClass(23, "someText");
CustomClass defaultObject = new CustomClass(67, "defaultText");
// when
prefser.put(givenKey, givenObject);
// then
CustomClass readObject = prefser.get(givenKey, CustomClass.class, defaultObject);
assertThat(givenObject).isEqualTo(readObject);
prefser.remove(givenKey);
}
@Test
public void testPutString() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
String givenValue = "sampleValueExplicit";
String defaultValue = "sampleDefaultValue";
// when
prefser.put(givenKey, givenValue);
// then
String readValue = prefser.get(givenKey, String.class, defaultValue);
assertThat(givenValue).isEqualTo(readValue);
prefser.remove(givenKey);
}
@Test
public void testPutDoublePrimitive() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
double givenValue = 44.5;
double defaultValue = 48.3;
// when
prefser.put(givenKey, givenValue);
// then
double readValue = prefser.get(givenKey, Double.class, defaultValue);
assertThat(givenValue).isEqualTo(readValue);
prefser.remove(givenKey);
}
@Test
public void testPutIntegerPrimitive() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
int givenValue = 42;
int defaultValue = 43;
// when
prefser.put(givenKey, givenValue);
// then
int readValue = prefser.get(givenKey, Integer.class, defaultValue);
assertThat(givenValue).isEqualTo(readValue);
prefser.remove(givenKey);
}
@Test
public void testPutFloatPrimitive() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
float givenValue = 41f;
float defaultValue = 42f;
// when
prefser.put(givenKey, givenValue);
// then
float readValue = prefser.get(givenKey, Float.class, defaultValue);
assertThat(givenValue).isEqualTo(readValue);
prefser.remove(givenKey);
}
@Test
public void testPutBooleanPrimitive() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
boolean givenValue = true;
boolean defaultValue = false;
// when
prefser.put(givenKey, givenValue);
// then
boolean readValue = prefser.get(givenKey, Boolean.class, defaultValue);
assertThat(givenValue).isEqualTo(readValue);
prefser.remove(givenKey);
}
@Test
public void testPutLongPrimitive() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
long givenValue = 43L;
long defaultValue = 44L;
// when
prefser.put(givenKey, givenValue);
// then
long readValue = prefser.get(givenKey, Long.class, defaultValue);
assertThat(givenValue).isEqualTo(readValue);
prefser.remove(givenKey);
}
@Test
public void testPutListOfStrings() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
List<String> strings = Arrays.asList("yet", "another", "list");
List<String> defaultStrings = Arrays.asList("default", "string", "values");
// when
prefser.put(givenKey, strings);
TypeToken<List<String>> typeToken = new TypeToken<List<String>>() {};
List<String> readObject = prefser.get(givenKey, typeToken, defaultStrings);
// then
assertThat(readObject).isEqualTo(strings);
prefser.remove(givenKey);
}
@Test
public void testPutListOfDoubles() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
List<Double> doubles = Arrays.asList(4.0, 5.1, 6.2);
List<Double> defaultDoubles = Arrays.asList(4.0, 5.1, 6.2);
// when
prefser.put(givenKey, doubles);
TypeToken<List<Double>> typeToken = new TypeToken<List<Double>>() {};
List<Double> readObject = prefser.get(givenKey, typeToken, defaultDoubles);
// then
assertThat(readObject).isEqualTo(doubles);
prefser.remove(givenKey);
}
@Test
public void testPutListOfIntegers() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
List<Integer> integers = Arrays.asList(1, 2, 3);
List<Integer> defaultIntegers = Arrays.asList(0, 0, 0);
// when
prefser.put(givenKey, integers);
// then
TypeToken<List<Integer>> typeToken = new TypeToken<List<Integer>>() {};
List<Integer> readObject = prefser.get(givenKey, typeToken, defaultIntegers);
assertThat(integers).isEqualTo(readObject);
prefser.remove(givenKey);
}
@Test
public void testPutListOfLongs() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
List<Long> longs = Arrays.asList(1L, 2L, 3L);
List<Long> defaultLongs = Arrays.asList(0L, 0L, 0L);
// when
prefser.put(givenKey, longs);
// then
TypeToken<List<Long>> typeToken = new TypeToken<List<Long>>() {};
List<Long> readObject = prefser.get(givenKey, typeToken, defaultLongs);
assertThat(longs).isEqualTo(readObject);
prefser.remove(givenKey);
}
@Test
public void testPutListOfBooleans() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
List<Boolean> booleans = Arrays.asList(true, false, true);
List<Boolean> defaultBooleans = Arrays.asList(false, false, false);
// when
prefser.put(givenKey, booleans);
// then
TypeToken<List<Boolean>> typeToken = new TypeToken<List<Boolean>>() {};
List<Boolean> readObject = prefser.get(givenKey, typeToken, defaultBooleans);
assertThat(booleans).isEqualTo(readObject);
prefser.remove(givenKey);
}
@Test
public void testPutListOfFloats() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
List<Float> floats = Arrays.asList(1.0f, 2.1f, 3.4f);
List<Float> defaultFloats = Arrays.asList(0f, 0f, 0f);
// when
prefser.put(givenKey, floats);
// then
TypeToken<List<Float>> typeToken = new TypeToken<List<Float>>() {};
List<Float> readObject = prefser.get(givenKey, typeToken, defaultFloats);
assertThat(floats).isEqualTo(readObject);
prefser.remove(givenKey);
}
@Test
public void testPutSetOfDoubles() {
// given
prefser.clear();
Set<Double> doubles = new HashSet<>(Arrays.asList(1.2, 2.3, 3.0));
Set<Double> defaultDoubles = new HashSet<>(Arrays.asList(1.0, 1.0, 1.0));
String givenKey = GIVEN_KEY;
// when
prefser.put(givenKey, doubles);
// then
TypeToken<Set<Double>> typeToken = new TypeToken<Set<Double>>() {};
Set<Double> readObject = prefser.get(givenKey, typeToken, defaultDoubles);
assertThat(readObject).isEqualTo(doubles);
assertThat(readObject).isInstanceOf(Set.class);
prefser.remove(givenKey);
}
@Test
public void testPutArrayOfStrings() {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
String[] strings = new String[] {"hey", "I am", "array of strings!"};
String[] defaultArray = new String[] {"", "", ""};
// when
prefser.put(givenKey, strings);
String[] readObject = prefser.get(givenKey, String[].class, defaultArray);
// then
assertThat(readObject[0]).isEqualTo(strings[0]);
assertThat(readObject[1]).isEqualTo(strings[1]);
assertThat(readObject[2]).isEqualTo(strings[2]);
prefser.remove(givenKey);
}
@Test
public void testPutArrayOfDoubles() {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
Double[] doubles = new Double[] {1.0, 2.3, 4.5};
Double[] defaultArray = new Double[] {1.0, 1.0, 1.0};
// when
prefser.put(givenKey, doubles);
Double[] readObject = prefser.get(givenKey, Double[].class, defaultArray);
// then
assertThat(readObject[0]).isEqualTo(doubles[0]);
assertThat(readObject[1]).isEqualTo(doubles[1]);
assertThat(readObject[2]).isEqualTo(doubles[2]);
prefser.remove(givenKey);
}
@Test
public void testPutArrayOfLongs() {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
Long[] longs = new Long[] {1L, 2L, 3L};
Long[] defaultArray = new Long[] {1L, 1L, 1L};
// when
prefser.put(givenKey, longs);
Long[] readObject = prefser.get(givenKey, Long[].class, defaultArray);
// then
assertThat(readObject[0]).isEqualTo(longs[0]);
assertThat(readObject[1]).isEqualTo(longs[1]);
assertThat(readObject[2]).isEqualTo(longs[2]);
prefser.remove(givenKey);
}
@Test
public void testPutArrayOfInts() {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
Integer[] integers = new Integer[] {1, 2, 3};
Integer[] defaultArray = new Integer[] {0, 0, 0};
// when
prefser.put(givenKey, integers);
Integer[] readObject = prefser.get(givenKey, Integer[].class, defaultArray);
// then
assertThat(readObject[0]).isEqualTo(integers[0]);
assertThat(readObject[1]).isEqualTo(integers[1]);
assertThat(readObject[2]).isEqualTo(integers[2]);
prefser.remove(givenKey);
}
@Test
public void testPutArrayOfFloats() {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
Float[] floats = new Float[] {1f, 2f, 3f};
Float[] defaultArray = new Float[] {1f, 1f, 1f};
// when
prefser.put(givenKey, floats);
Float[] readObject = prefser.get(givenKey, Float[].class, defaultArray);
// then
assertThat(readObject[0]).isEqualTo(floats[0]);
assertThat(readObject[1]).isEqualTo(floats[1]);
assertThat(readObject[2]).isEqualTo(floats[2]);
prefser.remove(givenKey);
}
@Test
public void testPutArrayOfBooleans() {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
Boolean[] booleans = new Boolean[] {true, false, true};
Boolean[] defaultArray = new Boolean[] {false, false, false};
// when
prefser.put(givenKey, booleans);
Boolean[] readObject = prefser.get(givenKey, Boolean[].class, defaultArray);
// then
assertThat(readObject[0]).isEqualTo(booleans[0]);
assertThat(readObject[1]).isEqualTo(booleans[1]);
assertThat(readObject[2]).isEqualTo(booleans[2]);
prefser.remove(givenKey);
}
@Test
public void testPutListOfCustomObjects() throws Exception {
// given
prefser.clear();
String givenKey = GIVEN_KEY;
CustomClass defaultCustomObject = new CustomClass(0, "zero");
List<CustomClass> customObjects =
Arrays.asList(
new CustomClass(1, "this is one"),
new CustomClass(2, "this is two"),
new CustomClass(3, "three"));
List<CustomClass> defaultCustomObjects =
Arrays.asList(defaultCustomObject, defaultCustomObject, defaultCustomObject);
// when
prefser.put(givenKey, customObjects);
TypeToken<List<CustomClass>> typeToken = new TypeToken<List<CustomClass>>() {};
List<CustomClass> readObject = prefser.get(givenKey, typeToken, defaultCustomObjects);
// then
assertThat(readObject).isEqualTo(customObjects);
prefser.remove(givenKey);
}
