Home | History | Annotate | Download | only in ui 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.tv.dvr.ui;
     18 
     19 import android.support.test.filters.SmallTest;
     20 import android.support.v17.leanback.widget.ClassPresenterSelector;
     21 import android.support.v17.leanback.widget.ObjectAdapter;
     22 
     23 import junit.framework.TestCase;
     24 
     25 import org.junit.Before;
     26 import org.junit.Test;
     27 
     28 import java.util.Arrays;
     29 import java.util.Comparator;
     30 import java.util.Objects;
     31 
     32 /**
     33  * Tests for {@link SortedArrayAdapter}.
     34  */
     35 @SmallTest
     36 public class SortedArrayAdapterTest extends TestCase {
     37     public static final TestData P1 = TestData.create(1, "c");
     38     public static final TestData P2 = TestData.create(2, "b");
     39     public static final TestData P3 = TestData.create(3, "a");
     40     public static final TestData EXTRA = TestData.create(4, "k");
     41     private TestSortedArrayAdapter mAdapter;
     42 
     43     @Before
     44     public void setUp() {
     45         mAdapter = new TestSortedArrayAdapter(Integer.MAX_VALUE, null);
     46     }
     47 
     48     @Test
     49     public void testContents_empty() {
     50         assertEmpty();
     51     }
     52 
     53     @Test
     54     public void testAdd_one() {
     55         mAdapter.add(P1);
     56         assertNotEmpty();
     57         assertContentsInOrder(mAdapter, P1);
     58     }
     59 
     60     @Test
     61     public void testAdd_two() {
     62         mAdapter.add(P1);
     63         mAdapter.add(P2);
     64         assertNotEmpty();
     65         assertContentsInOrder(mAdapter, P2, P1);
     66     }
     67 
     68     @Test
     69     public void testSetInitialItems_two() {
     70         mAdapter.setInitialItems(Arrays.asList(P1, P2));
     71         assertNotEmpty();
     72         assertContentsInOrder(mAdapter, P2, P1);
     73     }
     74 
     75     @Test
     76     public void testMaxInitialCount() {
     77         mAdapter = new TestSortedArrayAdapter(1, null);
     78         mAdapter.setInitialItems(Arrays.asList(P1, P2));
     79         assertNotEmpty();
     80         assertEquals(mAdapter.size(), 1);
     81         assertEquals(mAdapter.get(0), P2);
     82     }
     83 
     84     @Test
     85     public void testExtraItem() {
     86         mAdapter = new TestSortedArrayAdapter(Integer.MAX_VALUE, EXTRA);
     87         mAdapter.setInitialItems(Arrays.asList(P1, P2));
     88         assertNotEmpty();
     89         assertEquals(mAdapter.size(), 3);
     90         assertEquals(mAdapter.get(0), P2);
     91         assertEquals(mAdapter.get(2), EXTRA);
     92         mAdapter.remove(P2);
     93         mAdapter.remove(P1);
     94         assertEquals(mAdapter.size(), 1);
     95         assertEquals(mAdapter.get(0), EXTRA);
     96     }
     97 
     98     @Test
     99     public void testExtraItemWithMaxCount() {
    100         mAdapter = new TestSortedArrayAdapter(1, EXTRA);
    101         mAdapter.setInitialItems(Arrays.asList(P1, P2));
    102         assertNotEmpty();
    103         assertEquals(mAdapter.size(), 2);
    104         assertEquals(mAdapter.get(0), P2);
    105         assertEquals(mAdapter.get(1), EXTRA);
    106         mAdapter.remove(P2);
    107         assertEquals(mAdapter.size(), 1);
    108         assertEquals(mAdapter.get(0), EXTRA);
    109     }
    110 
    111     @Test
    112     public void testRemove() {
    113         mAdapter.add(P1);
    114         mAdapter.add(P2);
    115         assertNotEmpty();
    116         assertContentsInOrder(mAdapter, P2, P1);
    117         mAdapter.remove(P3);
    118         assertContentsInOrder(mAdapter, P2, P1);
    119         mAdapter.remove(P2);
    120         assertContentsInOrder(mAdapter, P1);
    121         mAdapter.remove(P1);
    122         assertEmpty();
    123         mAdapter.add(P1);
    124         mAdapter.add(P2);
    125         mAdapter.add(P3);
    126         assertContentsInOrder(mAdapter, P3, P2, P1);
    127         mAdapter.removeItems(0, 2);
    128         assertContentsInOrder(mAdapter, P1);
    129         mAdapter.add(P2);
    130         mAdapter.add(P3);
    131         mAdapter.addExtraItem(EXTRA);
    132         assertContentsInOrder(mAdapter, P3, P2, P1, EXTRA);
    133         mAdapter.removeItems(1, 1);
    134         assertContentsInOrder(mAdapter, P3, P1, EXTRA);
    135         mAdapter.removeItems(1, 2);
    136         assertContentsInOrder(mAdapter, P3);
    137         mAdapter.addExtraItem(EXTRA);
    138         mAdapter.addExtraItem(P2);
    139         mAdapter.add(P1);
    140         assertContentsInOrder(mAdapter, P3, P1, EXTRA, P2);
    141         mAdapter.removeItems(1, 2);
    142         assertContentsInOrder(mAdapter, P3, P2);
    143         mAdapter.add(P1);
    144         assertContentsInOrder(mAdapter, P3, P1, P2);
    145     }
    146 
    147     @Test
    148     public void testReplace() {
    149         mAdapter.add(P1);
    150         mAdapter.add(P2);
    151         assertNotEmpty();
    152         assertContentsInOrder(mAdapter, P2, P1);
    153         mAdapter.replace(1, P3);
    154         assertContentsInOrder(mAdapter, P3, P2);
    155         mAdapter.replace(0, P1);
    156         assertContentsInOrder(mAdapter, P2, P1);
    157         mAdapter.addExtraItem(EXTRA);
    158         assertContentsInOrder(mAdapter, P2, P1, EXTRA);
    159         mAdapter.replace(2, P3);
    160         assertContentsInOrder(mAdapter, P2, P1, P3);
    161     }
    162 
    163     @Test
    164     public void testChange_sorting() {
    165         TestData p2_changed = TestData.create(2, "z changed");
    166         mAdapter.add(P1);
    167         mAdapter.add(P2);
    168         assertNotEmpty();
    169         assertContentsInOrder(mAdapter, P2, P1);
    170         mAdapter.change(p2_changed);
    171         assertContentsInOrder(mAdapter, P1, p2_changed);
    172     }
    173 
    174     @Test
    175     public void testChange_new() {
    176         mAdapter.change(P1);
    177         assertNotEmpty();
    178         assertContentsInOrder(mAdapter, P1);
    179     }
    180 
    181     private void assertEmpty() {
    182         assertEquals("empty", true, mAdapter.isEmpty());
    183     }
    184 
    185     private void assertNotEmpty() {
    186         assertEquals("empty", false, mAdapter.isEmpty());
    187     }
    188 
    189     private static void assertContentsInOrder(ObjectAdapter adapter, Object... contents) {
    190         int ex = contents.length;
    191         assertEquals("size", ex, adapter.size());
    192         for (int i = 0; i < ex; i++) {
    193             assertEquals("element " + 1, contents[i], adapter.get(i));
    194         }
    195     }
    196 
    197     private static class TestData {
    198         @Override
    199         public String toString() {
    200             return "TestData[" + mId + "]{" + mText + '}';
    201         }
    202 
    203         static TestData create(long first, String text) {
    204             return new TestData(first, text);
    205         }
    206 
    207         private final long mId;
    208         private final String mText;
    209 
    210         private TestData(long id, String second) {
    211             this.mId = id;
    212             this.mText = second;
    213         }
    214 
    215         @Override
    216         public boolean equals(Object o) {
    217             if (this == o) return true;
    218             if (!(o instanceof TestData)) return false;
    219             TestData that = (TestData) o;
    220             return mId == that.mId && Objects.equals(mText, that.mText);
    221         }
    222 
    223         @Override
    224         public int hashCode() {
    225             return Objects.hash(mId, mText);
    226         }
    227     }
    228 
    229     private static class TestSortedArrayAdapter extends SortedArrayAdapter<TestData> {
    230 
    231         private static final Comparator<TestData> TEXT_COMPARATOR = new Comparator<TestData>() {
    232             @Override
    233             public int compare(TestData lhs, TestData rhs) {
    234                 return lhs.mText.compareTo(rhs.mText);
    235             }
    236         };
    237 
    238         TestSortedArrayAdapter(int maxInitialCount, Object extra) {
    239             super(new ClassPresenterSelector(), TEXT_COMPARATOR, maxInitialCount);
    240             if (extra != null) {
    241                 addExtraItem((TestData) extra);
    242             }
    243         }
    244 
    245         @Override
    246         protected long getId(TestData item) {
    247             return item.mId;
    248         }
    249     }
    250 }