Home | History | Annotate | Download | only in inputmethod
      1 /*
      2  * Copyright (C) 2014 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 android.view.inputmethod;
     18 
     19 import android.graphics.RectF;
     20 import android.os.Parcel;
     21 import android.test.InstrumentationTestCase;
     22 import android.test.suitebuilder.annotation.SmallTest;
     23 import android.view.inputmethod.SparseRectFArray.SparseRectFArrayBuilder;
     24 
     25 import java.util.Objects;
     26 
     27 public class SparseRectFArrayTest extends InstrumentationTestCase {
     28     // A test data for {@link SparseRectFArray}. null represents the gap of indices.
     29     private static final RectF[] MANY_RECTS = new RectF[] {
     30             null,
     31             new RectF(102.0f, 202.0f, 302.0f, 402.0f),
     32             new RectF(103.0f, 203.0f, 303.0f, 403.0f),
     33             new RectF(104.0f, 204.0f, 304.0f, 404.0f),
     34             new RectF(105.0f, 205.0f, 305.0f, 405.0f),
     35             new RectF(106.0f, 206.0f, 306.0f, 406.0f),
     36             null,
     37             new RectF(108.0f, 208.0f, 308.0f, 408.0f),
     38             new RectF(109.0f, 209.0f, 309.0f, 409.0f),
     39             new RectF(110.0f, 210.0f, 310.0f, 410.0f),
     40             new RectF(111.0f, 211.0f, 311.0f, 411.0f),
     41             new RectF(112.0f, 212.0f, 312.0f, 412.0f),
     42             new RectF(113.0f, 213.0f, 313.0f, 413.0f),
     43             new RectF(114.0f, 214.0f, 314.0f, 414.0f),
     44             new RectF(115.0f, 215.0f, 315.0f, 415.0f),
     45             new RectF(116.0f, 216.0f, 316.0f, 416.0f),
     46             new RectF(117.0f, 217.0f, 317.0f, 417.0f),
     47             null,
     48             null,
     49             new RectF(118.0f, 218.0f, 318.0f, 418.0f),
     50     };
     51 
     52     @SmallTest
     53     public void testBuilder() throws Exception {
     54         final RectF TEMP_RECT = new RectF(10.0f, 20.0f, 30.0f, 40.0f);
     55         final int TEMP_FLAGS = 0x1234;
     56 
     57         final SparseRectFArrayBuilder builder = new SparseRectFArrayBuilder();
     58         builder.append(100, TEMP_RECT.left, TEMP_RECT.top, TEMP_RECT.right, TEMP_RECT.bottom,
     59                 TEMP_FLAGS);
     60         assertNull(builder.build().get(-1));
     61         assertNull(builder.build().get(0));
     62         assertNull(builder.build().get(99));
     63         assertEquals(0, builder.build().getFlags(99, 0 /* valueIfKeyNotFound */));
     64         assertEquals(1, builder.build().getFlags(99, 1 /* valueIfKeyNotFound */));
     65         assertEquals(TEMP_RECT, builder.build().get(100));
     66         assertEquals(TEMP_FLAGS, builder.build().getFlags(100, 0 /* valueIfKeyNotFound */));
     67         assertEquals(TEMP_FLAGS, builder.build().getFlags(100, 1 /* valueIfKeyNotFound */));
     68         assertNull(builder.build().get(101));
     69         assertEquals(0, builder.build().getFlags(101, 0 /* valueIfKeyNotFound */));
     70         assertEquals(1, builder.build().getFlags(101, 1 /* valueIfKeyNotFound */));
     71 
     72         // Test if {@link SparseRectFArrayBuilder#reset} resets its internal state.
     73         builder.reset();
     74         assertNull(builder.build().get(100));
     75 
     76         builder.reset();
     77         for (int i = 0; i < MANY_RECTS.length; i++) {
     78             final RectF rect = MANY_RECTS[i];
     79             if (rect != null) {
     80                 builder.append(i, rect.left, rect.top, rect.right, rect.bottom, i);
     81             }
     82         }
     83         final SparseRectFArray array = builder.build();
     84         for (int i = 0; i < MANY_RECTS.length; i++) {
     85             final RectF expectedRect = MANY_RECTS[i];
     86             assertEquals(expectedRect, array.get(i));
     87             if (expectedRect != null) {
     88                 assertEquals(i, array.getFlags(i, 0x1234 /* valueIfKeyNotFound */));
     89                 assertEquals(i, array.getFlags(i, 0x4321 /* valueIfKeyNotFound */));
     90             } else {
     91                 assertEquals(0x1234, array.getFlags(i, 0x1234 /* valueIfKeyNotFound */));
     92                 assertEquals(0x4321, array.getFlags(i, 0x4321 /* valueIfKeyNotFound */));
     93             }
     94         }
     95 
     96         // Make sure the builder reproduces an equivalent object.
     97         final SparseRectFArray array2 = builder.build();
     98         for (int i = 0; i < MANY_RECTS.length; i++) {
     99             final RectF expectedRect = MANY_RECTS[i];
    100             assertEquals(expectedRect, array2.get(i));
    101             if (expectedRect != null) {
    102                 assertEquals(i, array2.getFlags(i, 0x1234 /* valueIfKeyNotFound */));
    103                 assertEquals(i, array2.getFlags(i, 0x4321 /* valueIfKeyNotFound */));
    104             } else {
    105                 assertEquals(0x1234, array2.getFlags(i, 0x1234 /* valueIfKeyNotFound */));
    106                 assertEquals(0x4321, array2.getFlags(i, 0x4321 /* valueIfKeyNotFound */));
    107             }
    108         }
    109         assertEqualRects(array, array2);
    110 
    111         // Make sure the instance can be marshaled via {@link Parcel}.
    112         final SparseRectFArray array3 = cloneViaParcel(array);
    113         for (int i = 0; i < MANY_RECTS.length; i++) {
    114             final RectF expectedRect = MANY_RECTS[i];
    115             assertEquals(expectedRect, array3.get(i));
    116             if (expectedRect != null) {
    117                 assertEquals(i, array3.getFlags(i, 0x1234 /* valueIfKeyNotFound */));
    118                 assertEquals(i, array3.getFlags(i, 0x4321 /* valueIfKeyNotFound */));
    119             } else {
    120                 assertEquals(0x1234, array3.getFlags(i, 0x1234 /* valueIfKeyNotFound */));
    121                 assertEquals(0x4321, array3.getFlags(i, 0x4321 /* valueIfKeyNotFound */));
    122             }
    123         }
    124         assertEqualRects(array, array3);
    125 
    126         // Make sure the builder can be reset.
    127         builder.reset();
    128         assertNull(builder.build().get(0));
    129     }
    130 
    131     @SmallTest
    132     public void testEquality() throws Exception {
    133         // Empty array should be equal.
    134         assertEqualRects(new SparseRectFArrayBuilder().build(),
    135                 new SparseRectFArrayBuilder().build());
    136 
    137         assertEqualRects(
    138                 new SparseRectFArrayBuilder().append(100, 1.0f, 2.0f, 3.0f, 4.0f, 1).build(),
    139                 new SparseRectFArrayBuilder().append(100, 1.0f, 2.0f, 3.0f, 4.0f, 1).build());
    140         assertEqualRects(
    141                 new SparseRectFArrayBuilder().append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0).build(),
    142                 new SparseRectFArrayBuilder().append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0).build());
    143         assertNotEqualRects(
    144                 new SparseRectFArrayBuilder().append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0).build(),
    145                 new SparseRectFArrayBuilder().append(100, 1.0f, 2.0f, 3.0f, 4.0f, 1).build());
    146         assertNotEqualRects(
    147                 new SparseRectFArrayBuilder().append(100, 1.0f, 2.0f, 3.0f, 4.0f, 1).build(),
    148                 new SparseRectFArrayBuilder().append(100, 2.0f, 2.0f, 3.0f, 4.0f, 1).build());
    149         assertNotEqualRects(
    150                 new SparseRectFArrayBuilder().append(100, 1.0f, 2.0f, 3.0f, 4.0f, 1).build(),
    151                 new SparseRectFArrayBuilder().append(101, 1.0f, 2.0f, 3.0f, 4.0f, 1).build());
    152 
    153         assertEqualRects(
    154                 new SparseRectFArrayBuilder()
    155                         .append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    156                         .append(101, 0.0f, 0.0f, 0.0f, 0.0f, 0).build(),
    157                 new SparseRectFArrayBuilder()
    158                         .append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    159                         .append(101, 0.0f, 0.0f, 0.0f, 0.0f, 0).build());
    160         assertNotEqualRects(
    161                 new SparseRectFArrayBuilder()
    162                         .append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0).build(),
    163                 new SparseRectFArrayBuilder()
    164                         .append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    165                         .append(101, 0.0f, 0.0f, 0.0f, 0.0f, 0).build());
    166         assertNotEqualRects(
    167                 new SparseRectFArrayBuilder()
    168                         .append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    169                         .append(101, 0.0f, 0.0f, 0.0f, 0.0f, 0).build(),
    170                 new SparseRectFArrayBuilder()
    171                         .append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0).build());
    172         assertNotEqualRects(
    173                 new SparseRectFArrayBuilder()
    174                         .append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    175                         .append(101, 0.0f, 0.0f, 0.0f, 0.0f, 0).build(),
    176                 new SparseRectFArrayBuilder()
    177                         .append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    178                         .append(101, 1.0f, 0.0f, 0.0f, 0.0f, 0).build());
    179         assertNotEqualRects(
    180                 new SparseRectFArrayBuilder()
    181                         .append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    182                         .append(101, 1.0f, 0.0f, 0.0f, 0.0f, 0).build(),
    183                 new SparseRectFArrayBuilder()
    184                         .append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    185                         .append(101, 0.0f, 0.0f, 0.0f, 0.0f, 0).build());
    186         assertNotEqualRects(
    187                 new SparseRectFArrayBuilder()
    188                         .append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    189                         .append(101, 0.0f, 0.0f, 0.0f, 0.0f, 0).build(),
    190                 new SparseRectFArrayBuilder()
    191                         .append(100, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    192                         .append(102, 0.0f, 0.0f, 0.0f, 0.0f, 0).build());
    193 
    194         assertEqualRects(
    195                 new SparseRectFArrayBuilder()
    196                         .append(1, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    197                         .append(1000, 0.0f, 0.0f, 0.0f, 0.0f, 0)
    198                         .append(100000000, 0.0f, 0.0f, 0.0f, 0.0f, 0)
    199                         .build(),
    200                 new SparseRectFArrayBuilder()
    201                         .append(1, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    202                         .append(1000, 0.0f, 0.0f, 0.0f, 0.0f, 0)
    203                         .append(100000000, 0.0f, 0.0f, 0.0f, 0.0f, 0)
    204                         .build());
    205 
    206         assertNotEqualRects(
    207                 new SparseRectFArrayBuilder()
    208                         .append(1, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    209                         .append(1000, 0.0f, 0.0f, 0.0f, 0.0f, 0)
    210                         .append(100000000, 0.0f, 0.0f, 0.0f, 0.0f, 0)
    211                         .build(),
    212                 new SparseRectFArrayBuilder()
    213                         .append(1, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    214                         .build());
    215         assertNotEqualRects(
    216                 new SparseRectFArrayBuilder()
    217                         .append(1, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    218                         .append(1000, 0.0f, 0.0f, 0.0f, 0.0f, 0)
    219                         .append(100000000, 0.0f, 0.0f, 0.0f, 0.0f, 0)
    220                         .build(),
    221                 new SparseRectFArrayBuilder()
    222                         .append(1, 1.0f, 2.0f, 3.0f, 4.0f, 0)
    223                         .append(1000, 1.0f, 0.0f, 0.0f, 0.0f, 0)
    224                         .append(100000000, 0.0f, 0.0f, 0.0f, 0.0f, 0)
    225                         .build());
    226     }
    227 
    228     @SmallTest
    229     public void testBuilderAppend() throws Exception {
    230         // Key should be appended in ascending order.
    231         try {
    232             new SparseRectFArrayBuilder()
    233                     .append(10, 0.0f, 0.0f, 0.0f, 0.0f, 0)
    234                     .append(0, 1.0f, 2.0f, 3.0f, 4.0f, 0);
    235         } catch (IllegalArgumentException ex) {
    236             assertTrue(true);
    237         }
    238 
    239         try {
    240             new SparseRectFArrayBuilder()
    241                     .append(10, 0.0f, 0.0f, 0.0f, 0.0f, 0)
    242                     .append(10, 1.0f, 2.0f, 3.0f, 4.0f, 0);
    243         } catch (IllegalArgumentException ex) {
    244             assertTrue(true);
    245         }
    246     }
    247 
    248     private static void assertEqualRects(SparseRectFArray a, SparseRectFArray b) {
    249         assertEquals(a, b);
    250         if (a != null && b != null) {
    251             assertEquals(a.hashCode(), b.hashCode());
    252         }
    253     }
    254 
    255     private static void assertNotEqualRects(SparseRectFArray a, SparseRectFArray b) {
    256         assertFalse(Objects.equals(a, b));
    257     }
    258 
    259     private static SparseRectFArray cloneViaParcel(final SparseRectFArray src) {
    260         Parcel parcel = null;
    261         try {
    262             parcel = Parcel.obtain();
    263             src.writeToParcel(parcel, 0);
    264             parcel.setDataPosition(0);
    265             return new SparseRectFArray(parcel);
    266         } finally {
    267             if (parcel != null) {
    268                 parcel.recycle();
    269             }
    270         }
    271     }
    272 }
    273