| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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 org.osgi.util.converter; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.junit.Test; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertTrue; |
| |
| public class ConverterCollectionsTest { |
| @Test |
| public void testLiveBackingList() { |
| List<Integer> l = Arrays.asList(9, 8, 7); |
| Converter converter = Converters.standardConverter(); |
| List<Short> sl = converter.convert(l).view() |
| .to(new TypeReference<List<Short>>() {}); |
| |
| assertEquals(Short.valueOf((short) 9), sl.get(0)); |
| assertEquals(Short.valueOf((short) 8), sl.get(1)); |
| assertEquals(Short.valueOf((short) 7), sl.get(2)); |
| assertEquals(3, sl.size()); |
| |
| l.set(1, 11); |
| assertEquals(Short.valueOf((short) 9), sl.get(0)); |
| assertEquals(Short.valueOf((short) 11), sl.get(1)); |
| assertEquals(Short.valueOf((short) 7), sl.get(2)); |
| assertEquals(3, sl.size()); |
| |
| List<Short> sl2 = converter.convert(l).view() |
| .to(new TypeReference<List<Short>>() {}); |
| List<Short> sl3 = converter.convert(l).view() |
| .to(new TypeReference<List<Short>>() {}); |
| sl3.add(Short.valueOf((short) 6)); |
| |
| assertEquals(sl.hashCode(), sl2.hashCode()); |
| assertTrue(sl.hashCode() != sl3.hashCode()); |
| |
| assertEquals(sl, sl2); |
| assertFalse(sl.equals(sl3)); |
| } |
| |
| @Test |
| public void testLiveBackingList1() { |
| long[] a = new long[] { |
| 9l, 8l |
| }; |
| |
| List<Integer> l = Converters.standardConverter().convert(a).view().to( |
| new TypeReference<List<Integer>>() {}); |
| a[0] = 7l; |
| l.addAll(Arrays.asList(7, 6)); |
| a[0] = 1l; |
| assertEquals(Arrays.asList(7, 8, 7, 6), l); |
| } |
| |
| @Test |
| public void testLiveBackingList2() { |
| long[] a = new long[] { |
| 9l, 8l |
| }; |
| |
| List<Integer> l = Converters.standardConverter().convert(a).view().to( |
| new TypeReference<List<Integer>>() {}); |
| l.addAll(1, Arrays.asList(7, 6)); |
| a[0] = 1l; |
| assertEquals(Arrays.asList(9, 7, 6, 8), l); |
| } |
| |
| @Test |
| public void testLiveBackingList3() { |
| long[] a = new long[] { |
| 9l, 8l |
| }; |
| |
| List<Integer> l = Converters.standardConverter().convert(a).view().to( |
| new TypeReference<List<Integer>>() {}); |
| l.removeAll(Collections.singleton(8)); |
| a[0] = 1l; |
| assertEquals(Collections.singletonList(9), l); |
| } |
| |
| @Test |
| public void testLiveBackingList4() { |
| long[] a = new long[] { |
| 9l, 8l |
| }; |
| |
| List<Integer> l = Converters.standardConverter().convert(a).view().to( |
| new TypeReference<List<Integer>>() {}); |
| l.retainAll(Collections.singleton(8)); |
| a[1] = 1l; |
| assertEquals(Collections.singletonList(8), l); |
| } |
| |
| @Test |
| public void testLiveBackingList5() { |
| long[] a = new long[] { |
| 9l, 8l |
| }; |
| |
| List<Integer> l = Converters.standardConverter().convert(a).view().to( |
| new TypeReference<List<Integer>>() {}); |
| l.clear(); |
| l.add(10); |
| a[0] = 1l; |
| assertEquals(Collections.singletonList(10), l); |
| } |
| |
| @Test |
| public void testLiveBackingList6() { |
| long[] a = new long[] { |
| 9l, 8l |
| }; |
| |
| List<Integer> l = Converters.standardConverter().convert(a).view().to( |
| new TypeReference<List<Integer>>() {}); |
| l.add(10); |
| a[0] = 1l; |
| assertEquals(Arrays.asList(9, 8, 10), l); |
| } |
| |
| @Test |
| public void testLiveBackingList7() { |
| long[] a = new long[] { |
| 9l, 8l |
| }; |
| |
| List<Integer> l = Converters.standardConverter().convert(a).view().to( |
| new TypeReference<List<Integer>>() {}); |
| l.add(0, 10); |
| a[0] = 1l; |
| assertEquals(Arrays.asList(10, 9, 8), l); |
| } |
| |
| @Test |
| public void testLiveBackingList8() { |
| long[] a = new long[] { |
| 9l, 8l |
| }; |
| |
| List<Integer> l = Converters.standardConverter().convert(a).view().to( |
| new TypeReference<List<Integer>>() {}); |
| assertEquals(Integer.valueOf(8), l.remove(1)); |
| a[0] = 1l; |
| assertEquals(Arrays.asList(9), l); |
| } |
| |
| @Test |
| public void testLiveBackingCollection() { |
| Set<String> s = new LinkedHashSet<>(Arrays.asList("yo", "yo", "ma")); |
| Converter converter = Converters.standardConverter(); |
| List<String> sl = converter.convert(s).view() |
| .to(new TypeReference<List<String>>() {}); |
| |
| assertEquals("yo", sl.get(0)); |
| assertEquals("ma", sl.get(1)); |
| assertEquals(2, sl.size()); |
| |
| s.add("ha"); |
| s.add("yo"); |
| assertEquals("yo", sl.get(0)); |
| assertEquals("ma", sl.get(1)); |
| assertEquals("ha", sl.get(2)); |
| assertEquals(3, sl.size()); |
| assertFalse(sl.isEmpty()); |
| |
| assertTrue(sl.contains("ma")); |
| assertFalse(sl.contains("na")); |
| |
| String[] sa = sl.toArray(new String[] {}); |
| assertEquals(3, sa.length); |
| assertEquals("yo", sa[0]); |
| assertEquals("ma", sa[1]); |
| assertEquals("ha", sa[2]); |
| |
| assertTrue(sl.containsAll(Arrays.asList("ma", "yo"))); |
| assertFalse(sl.containsAll(Arrays.asList("xxx"))); |
| } |
| |
| @Test |
| public void testLiveBackingEmptyCollection() { |
| Set<Long> s = Collections.emptySet(); |
| Collection< ? > l = Converters.standardConverter().convert(s).view().to( |
| Collection.class); |
| assertTrue(l.isEmpty()); |
| assertEquals(0, l.size()); |
| } |
| |
| @Test |
| public void testLiveBackingArray() { |
| Converter converter = Converters.standardConverter(); |
| int[] arr = new int[] { |
| 1, 2 |
| }; |
| |
| @SuppressWarnings("rawtypes") |
| List l = converter.convert(arr).view().to(List.class); |
| assertEquals(2, l.size()); |
| assertFalse(l.isEmpty()); |
| assertEquals(1, l.get(0)); |
| assertEquals(2, l.get(1)); |
| |
| assertTrue(l.contains(1)); |
| assertTrue(l.contains(2)); |
| assertFalse(l.contains(3)); |
| assertFalse(l.contains(0)); |
| |
| arr[0] = -3; |
| arr[1] = 3; |
| assertEquals(-3, l.get(0)); |
| assertEquals(3, l.get(1)); |
| } |
| |
| @Test |
| public void testLiveBackingMixedArrayWithNulls() { |
| Object[] oa = new Object[] { |
| "hi", null, 'x' |
| }; |
| List< ? > l = Converters.standardConverter().convert(oa).view().to(List.class); |
| assertTrue(l.contains("hi")); |
| assertTrue(l.contains(null)); |
| assertTrue(l.contains('x')); |
| assertFalse(l.containsAll(Arrays.asList('x', 7))); |
| assertTrue(l.containsAll(Arrays.asList('x', null, null, "hi", "hi"))); |
| assertEquals(0, l.indexOf("hi")); |
| assertEquals(1, l.indexOf(null)); |
| assertEquals(2, l.indexOf('x')); |
| assertEquals(-1, l.indexOf("test")); |
| |
| List< ? > l0 = l.subList(1, 1); |
| assertEquals(0, l0.size()); |
| List< ? > l1 = l.subList(1, 2); |
| assertEquals(Arrays.asList((Object) null), l1); |
| List< ? > l2 = l.subList(1, 3); |
| assertEquals(Arrays.asList(null, 'x'), l2); |
| List< ? > l3 = l.subList(0, 2); |
| assertEquals(Arrays.asList("hi", null), l3); |
| } |
| |
| @Test |
| public void testLiveStringArray() { |
| String[] sa = new String[] { |
| "yo", "ho", "yo", null, "yo" |
| }; |
| |
| List<String> l = Converters.standardConverter().convert(sa).view().to( |
| new TypeReference<List<String>>() {}); |
| Object[] oa1 = l.toArray(); |
| String[] sa1 = l.toArray(new String[] {}); |
| assertEquals("yo", sa1[0]); |
| assertEquals("ho", sa1[1]); |
| assertEquals("yo", sa1[2]); |
| assertNull(sa1[3]); |
| assertEquals("yo", sa1[4]); |
| assertEquals(oa1[0], sa1[0]); |
| assertEquals(oa1[1], sa1[1]); |
| assertEquals(oa1[2], sa1[2]); |
| assertEquals(oa1[3], sa1[3]); |
| assertEquals(oa1[4], sa1[4]); |
| assertEquals(5, oa1.length); |
| assertEquals(5, sa1.length); |
| |
| String[] sa2 = l.toArray(new String[6]); |
| assertEquals(oa1[0], sa2[0]); |
| assertEquals(oa1[1], sa2[1]); |
| assertEquals(oa1[2], sa2[2]); |
| assertEquals(oa1[3], sa2[3]); |
| assertEquals(oa1[4], sa2[4]); |
| assertNull(sa2[5]); |
| assertEquals(6, sa2.length); |
| |
| assertEquals(4, l.lastIndexOf("yo")); |
| assertEquals(1, l.lastIndexOf("ho")); |
| assertEquals(3, l.lastIndexOf(null)); |
| assertEquals(-1, l.lastIndexOf(123)); |
| } |
| |
| @Test |
| public void testLiveBackingArray0() { |
| Converter converter = Converters.standardConverter(); |
| List< ? > l = converter.convert(new double[] {}).view().to(List.class); |
| assertTrue(l.isEmpty()); |
| assertEquals(0, l.size()); |
| } |
| |
| @Test |
| public void testLiveBackingArray1() { |
| Converter converter = Converters.standardConverter(); |
| Integer[] arr = new Integer[] {1, 2}; |
| |
| @SuppressWarnings("rawtypes") |
| List l = converter.convert(arr).view().to(List.class); |
| assertEquals(1, l.get(0)); |
| assertEquals(2, l.get(1)); |
| |
| arr[0] = -3; |
| arr[1] = 3; |
| assertEquals(-3, l.get(0)); |
| assertEquals(3, l.get(1)); |
| } |
| |
| @Test |
| public void testLiveBackingArray2() { |
| Converter converter = Converters.standardConverter(); |
| Integer[] arr = new Integer[] {1, 2}; |
| |
| List<Long> l = converter.convert(arr).view().to(new TypeReference<List<Long>>() {}); |
| assertTrue(l.contains(Long.valueOf(2))); |
| assertTrue( |
| l.containsAll(Arrays.asList(Long.valueOf(2), Long.valueOf(1)))); |
| assertFalse(l.contains(Long.valueOf(3))); |
| assertFalse( |
| l.containsAll(Arrays.asList(Long.valueOf(2), Long.valueOf(3)))); |
| |
| arr[0] = Integer.valueOf(3); |
| assertTrue(l.contains(Long.valueOf(2))); |
| assertFalse( |
| l.containsAll(Arrays.asList(Long.valueOf(2), Long.valueOf(1)))); |
| assertTrue(l.contains(Long.valueOf(3))); |
| assertTrue( |
| l.containsAll(Arrays.asList(Long.valueOf(2), Long.valueOf(3)))); |
| |
| l.add(Long.valueOf(4)); |
| l.add(Long.valueOf(5)); |
| arr[0] = Integer.valueOf(1); |
| assertTrue(l.containsAll(Arrays.asList(Long.valueOf(2), Long.valueOf(3), |
| Long.valueOf(4), Long.valueOf(5)))); |
| } |
| |
| @Test |
| public void testLiveBackingArray3() { |
| Converter converter = Converters.standardConverter(); |
| Integer[] arr = new Integer[] { |
| 1, 2 |
| }; |
| |
| List<Long> l = converter.convert(arr).view() |
| .to(new TypeReference<List<Long>>() {}); |
| assertTrue(l.remove(Long.valueOf(1))); |
| arr[1] = Integer.valueOf(3); |
| assertEquals(Collections.singletonList(Long.valueOf(2)), l); |
| } |
| |
| @Test |
| public void testLiveArrayBackingSet() { |
| char[] ca = new char[] { |
| 'a', 'b', 'c' |
| }; |
| |
| Set<Character> s = Converters.standardConverter().convert(ca).view().to( |
| new TypeReference<Set<Character>>() {}); |
| assertTrue(s.containsAll(Arrays.asList(Character.valueOf('a'), |
| Character.valueOf('b'), Character.valueOf('c')))); |
| |
| ca[0] = 'd'; |
| assertTrue(s.containsAll(Arrays.asList(Character.valueOf('b'), |
| Character.valueOf('c'), Character.valueOf('d')))); |
| } |
| |
| @Test |
| public void testLiveBackingSet() { |
| List<Double> l = new ArrayList<>(); |
| l.add(3.1415); |
| |
| Set<Float> s = Converters.standardConverter().convert(l).view().to( |
| new TypeReference<Set<Float>>() {}); |
| Float f1 = Float.valueOf(3.1415f); |
| Float f2 = Float.valueOf(1.0f); |
| assertEquals(1, s.size()); |
| assertFalse(s.isEmpty()); |
| assertTrue(s.contains(f1)); |
| assertFalse(s.contains(f2)); |
| assertEquals(f1, s.iterator().next()); |
| |
| l.set(0, null); |
| assertEquals(1, s.size()); |
| assertFalse(s.isEmpty()); |
| assertTrue(s.contains(null)); |
| assertFalse(s.contains(f2)); |
| assertFalse(s.contains(f1)); |
| assertNull(s.iterator().next()); |
| |
| Float f3 = Float.valueOf(2.7182f); |
| s.add(f3); |
| assertEquals("Original should not be modified", 1, l.size()); |
| l.set(0, -1.0); |
| assertEquals(2, s.size()); |
| assertTrue(s.contains(null)); |
| assertTrue(s.contains(f3)); |
| assertFalse(s.contains(f2)); |
| assertFalse(s.contains(f1)); |
| } |
| |
| @Test |
| public void testLiveBackingSet0() { |
| List<String> l = new ArrayList<>(); |
| l.addAll(Arrays.asList("hi", "there")); |
| |
| Set<String> s = Converters.standardConverter().convert(l).view().to( |
| new TypeReference<Set<String>>() {}); |
| l.set(0, "ho"); |
| |
| String[] sa = s.toArray(new String[1]); |
| assertEquals(Arrays.asList("ho", "there"), Arrays.asList(sa)); |
| |
| String[] sa2 = s.toArray(new String[4]); |
| assertEquals(Arrays.asList("ho", "there", null, null), |
| Arrays.asList(sa2)); |
| |
| Set<String> s2 = Converters.standardConverter().convert(l).view().to( |
| new TypeReference<Set<String>>() {}); |
| Set<String> s3 = Converters.standardConverter().convert(l).view().to( |
| new TypeReference<Set<String>>() {}); |
| s3.add("!!"); |
| assertEquals(s.hashCode(), s2.hashCode()); |
| assertFalse(s.hashCode() == s3.hashCode()); |
| |
| assertTrue(s.equals(s2)); |
| assertFalse(s.equals(s3)); |
| } |
| |
| @Test |
| public void testLiveBackingSet1() { |
| List<String> l = new ArrayList<>(); |
| l.addAll(Arrays.asList("hi", "there")); |
| |
| Set<CharSequence> s = Converters.standardConverter().convert(l).view().to( |
| new TypeReference<Set<CharSequence>>() {}); |
| assertTrue(s.containsAll(Arrays.asList("there", "hi"))); |
| s.clear(); |
| assertEquals("Original should not be modified", Arrays.asList("hi", "there"), l); |
| assertEquals(0, s.size()); |
| assertTrue(s.isEmpty()); |
| } |
| |
| @Test |
| public void testLiveBackingSet2() { |
| List<String> l = new ArrayList<>(); |
| l.addAll(Arrays.asList("hi", "there")); |
| |
| Set<CharSequence> s = Converters.standardConverter().convert(l).view().to( |
| new TypeReference<Set<CharSequence>>() {}); |
| s.remove("yo"); |
| l.set(0, "xxx"); // Should not have an effect since 'remove' was called |
| assertTrue(s.containsAll(Arrays.asList("there", "hi"))); |
| |
| s.remove("hi"); |
| assertEquals(Collections.singleton("there"), s); |
| } |
| |
| @Test |
| public void testLiveBackingSet3() { |
| List<String> l = new ArrayList<>(); |
| l.addAll(Arrays.asList("hi", "there")); |
| |
| Set<CharSequence> s = Converters.standardConverter().convert(l).view().to( |
| new TypeReference<Set<CharSequence>>() {}); |
| assertFalse(s.addAll(Collections.singleton("there"))); |
| assertTrue(s.addAll(Arrays.asList("there", "!!"))); |
| l.remove("hi"); |
| assertTrue(s.containsAll(Arrays.asList("there", "hi", "!!"))); |
| } |
| |
| @Test |
| public void testLiveBackingSet4() { |
| List<String> l = new ArrayList<>(); |
| l.addAll(Arrays.asList("hi", "there")); |
| |
| Set<CharSequence> s = Converters.standardConverter().convert(l).view().to( |
| new TypeReference<Set<CharSequence>>() {}); |
| assertFalse(s.removeAll(Collections.singleton("yo"))); |
| l.remove("hi"); |
| assertTrue(s.containsAll(Arrays.asList("there", "hi"))); |
| assertTrue(s.removeAll(Arrays.asList("there", "hi"))); |
| assertEquals(0, s.size()); |
| } |
| |
| @Test |
| public void testLiveBackingSet5() { |
| List<String> l = new ArrayList<>(); |
| l.addAll(Arrays.asList("hi", "there")); |
| |
| Set<CharSequence> s = Converters.standardConverter().convert(l).view().to( |
| new TypeReference<Set<CharSequence>>() {}); |
| |
| assertTrue(s.retainAll(Arrays.asList("hi", "!!"))); |
| assertEquals(new HashSet<>(Collections.singleton("hi")), s); |
| } |
| } |