frameworks/base/core/tests/coretests/src/android/pim/vcard/test_utils/PropertyNodesVerifierElem.java

   1 /*
   2  * Copyright (C) 2010 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 package android.pim.vcard.test_utils;
  17
  18 import android.content.ContentValues;
  19 import android.test.AndroidTestCase;
  20
  21 import junit.framework.TestCase;
  22
  23 import java.util.ArrayList;
  24 import java.util.Arrays;
  25 import java.util.HashMap;
  26 import java.util.HashSet;
  27 import java.util.List;
  28
  29 /**
  30  * Utility class which verifies input VNode.
  31  *
  32  * This class first checks whether each propertyNode in the VNode is in the
  33  * "ordered expected property list".
  34  * If the node does not exist in the "ordered list", the class refers to
  35  * "unorderd expected property set" and checks the node is expected somewhere.
  36  */
  37 public class PropertyNodesVerifierElem {
  38     public static class TypeSet extends HashSet<String> {
  39         public TypeSet(String ... array) {
  40             super(Arrays.asList(array));
  41         }
  42     }
  43
  44     public static class GroupSet extends HashSet<String> {
  45         public GroupSet(String ... array) {
  46             super(Arrays.asList(array));
  47         }
  48     }
  49
  50     private final HashMap<String, List<PropertyNode>> mOrderedNodeMap;
  51     // Intentionally use ArrayList instead of Set, assuming there may be more than one
  52     // exactly same objects.
  53     private final ArrayList<PropertyNode> mUnorderedNodeList;
  54
  55     public PropertyNodesVerifierElem(AndroidTestCase androidTestCase) {
  56         mOrderedNodeMap = new HashMap<String, List<PropertyNode>>();
  57         mUnorderedNodeList = new ArrayList<PropertyNode>();
  58     }
  59
  60     // WithOrder
  61
  62     public PropertyNodesVerifierElem addExpectedNodeWithOrder(String propName, String propValue) {
  63         return addExpectedNodeWithOrder(propName, propValue, null, null, null, null, null);
  64     }
  65
  66     public PropertyNodesVerifierElem addExpectedNodeWithOrder(
  67             String propName, String propValue, ContentValues contentValues) {
  68         return addExpectedNodeWithOrder(propName, propValue, null,
  69                 null, contentValues, null, null);
  70     }
  71
  72     public PropertyNodesVerifierElem addExpectedNodeWithOrder(
  73             String propName, List<String> propValueList, ContentValues contentValues) {
  74         return addExpectedNodeWithOrder(propName, null, propValueList,
  75                 null, contentValues, null, null);
  76     }
  77
  78     public PropertyNodesVerifierElem addExpectedNodeWithOrder(
  79             String propName, String propValue, List<String> propValueList) {
  80         return addExpectedNodeWithOrder(propName, propValue, propValueList, null,
  81                 null, null, null);
  82     }
  83
  84     public PropertyNodesVerifierElem addExpectedNodeWithOrder(
  85             String propName, List<String> propValueList) {
  86         final String propValue = concatinateListWithSemiColon(propValueList);
  87         return addExpectedNodeWithOrder(propName, propValue.toString(), propValueList,
  88                 null, null, null, null);
  89     }
  90
  91     public PropertyNodesVerifierElem addExpectedNodeWithOrder(String propName, String propValue,
  92             TypeSet paramMap_TYPE) {
  93         return addExpectedNodeWithOrder(propName, propValue, null,
  94                 null, null, paramMap_TYPE, null);
  95     }
  96
  97     public PropertyNodesVerifierElem addExpectedNodeWithOrder(String propName,
  98             List<String> propValueList, TypeSet paramMap_TYPE) {
  99         return addExpectedNodeWithOrder(propName, null, propValueList, null, null,
 100                 paramMap_TYPE, null);
 101     }
 102
 103     public PropertyNodesVerifierElem addExpectedNodeWithOrder(String propName,
 104             List<String> propValueList, ContentValues paramMap, TypeSet paramMap_TYPE) {
 105         return addExpectedNodeWithOrder(propName, null, propValueList, null, paramMap,
 106                 paramMap_TYPE, null);
 107     }
 108
 109     public PropertyNodesVerifierElem addExpectedNodeWithOrder(String propName, String propValue,
 110             ContentValues paramMap, TypeSet paramMap_TYPE) {
 111         return addExpectedNodeWithOrder(propName, propValue, null, null,
 112                 paramMap, paramMap_TYPE, null);
 113     }
 114
 115     public PropertyNodesVerifierElem addExpectedNodeWithOrder(String propName, String propValue,
 116             List<String> propValueList, TypeSet paramMap_TYPE) {
 117         return addExpectedNodeWithOrder(propName, propValue, propValueList, null, null,
 118                 paramMap_TYPE, null);
 119     }
 120
 121     public PropertyNodesVerifierElem addExpectedNodeWithOrder(String propName, String propValue,
 122             List<String> propValueList, ContentValues paramMap) {
 123         return addExpectedNodeWithOrder(propName, propValue, propValueList, null, paramMap,
 124                 null, null);
 125     }
 126
 127     public PropertyNodesVerifierElem addExpectedNodeWithOrder(String propName, String propValue,
 128             List<String> propValueList, byte[] propValue_bytes,
 129             ContentValues paramMap, TypeSet paramMap_TYPE, GroupSet propGroupSet) {
 130         if (propValue == null && propValueList != null) {
 131             propValue = concatinateListWithSemiColon(propValueList);
 132         }
 133         final PropertyNode propertyNode = new PropertyNode(propName,
 134                 propValue, propValueList, propValue_bytes,
 135                 paramMap, paramMap_TYPE, propGroupSet);
 136         List<PropertyNode> expectedNodeList = mOrderedNodeMap.get(propName);
 137         if (expectedNodeList == null) {
 138             expectedNodeList = new ArrayList<PropertyNode>();
 139             mOrderedNodeMap.put(propName, expectedNodeList);
 140         }
 141         expectedNodeList.add(propertyNode);
 142         return this;
 143     }
 144
 145     // WithoutOrder
 146
 147     public PropertyNodesVerifierElem addExpectedNode(String propName, String propValue) {
 148         return addExpectedNode(propName, propValue, null, null, null, null, null);
 149     }
 150
 151     public PropertyNodesVerifierElem addExpectedNode(String propName, String propValue,
 152             ContentValues contentValues) {
 153         return addExpectedNode(propName, propValue, null, null, contentValues, null, null);
 154     }
 155
 156     public PropertyNodesVerifierElem addExpectedNode(String propName,
 157             List<String> propValueList, ContentValues contentValues) {
 158         return addExpectedNode(propName, null,
 159                 propValueList, null, contentValues, null, null);
 160     }
 161
 162     public PropertyNodesVerifierElem addExpectedNode(String propName, String propValue,
 163             List<String> propValueList) {
 164         return addExpectedNode(propName, propValue, propValueList, null, null, null, null);
 165     }
 166
 167     public PropertyNodesVerifierElem addExpectedNode(String propName,
 168             List<String> propValueList) {
 169         return addExpectedNode(propName, null, propValueList,
 170                 null, null, null, null);
 171     }
 172
 173     public PropertyNodesVerifierElem addExpectedNode(String propName, String propValue,
 174             TypeSet paramMap_TYPE) {
 175         return addExpectedNode(propName, propValue, null, null, null, paramMap_TYPE, null);
 176     }
 177
 178     public PropertyNodesVerifierElem addExpectedNode(String propName,
 179             List<String> propValueList, TypeSet paramMap_TYPE) {
 180         final String propValue = concatinateListWithSemiColon(propValueList);
 181         return addExpectedNode(propName, propValue, propValueList, null, null,
 182                 paramMap_TYPE, null);
 183     }
 184
 185     public PropertyNodesVerifierElem addExpectedNode(String propName, String propValue,
 186             List<String> propValueList, TypeSet paramMap_TYPE) {
 187         return addExpectedNode(propName, propValue, propValueList, null, null,
 188                 paramMap_TYPE, null);
 189     }
 190
 191     public PropertyNodesVerifierElem addExpectedNode(String propName, String propValue,
 192             ContentValues paramMap, TypeSet paramMap_TYPE) {
 193         return addExpectedNode(propName, propValue, null, null,
 194                 paramMap, paramMap_TYPE, null);
 195     }
 196
 197     public PropertyNodesVerifierElem addExpectedNode(String propName, String propValue,
 198             List<String> propValueList, byte[] propValue_bytes,
 199             ContentValues paramMap, TypeSet paramMap_TYPE, GroupSet propGroupSet) {
 200         if (propValue == null && propValueList != null) {
 201             propValue = concatinateListWithSemiColon(propValueList);
 202         }
 203         mUnorderedNodeList.add(new PropertyNode(propName, propValue,
 204                 propValueList, propValue_bytes, paramMap, paramMap_TYPE, propGroupSet));
 205         return this;
 206     }
 207
 208     public void verify(VNode vnode) {
 209         for (PropertyNode actualNode : vnode.propList) {
 210             verifyNode(actualNode.propName, actualNode);
 211         }
 212
 213         if (!mOrderedNodeMap.isEmpty() || !mUnorderedNodeList.isEmpty()) {
 214             final List<String> expectedProps = new ArrayList<String>();
 215             for (List<PropertyNode> nodes : mOrderedNodeMap.values()) {
 216                 for (PropertyNode node : nodes) {
 217                     if (!expectedProps.contains(node.propName)) {
 218                         expectedProps.add(node.propName);
 219                     }
 220                 }
 221             }
 222             for (PropertyNode node : mUnorderedNodeList) {
 223                 if (!expectedProps.contains(node.propName)) {
 224                     expectedProps.add(node.propName);
 225                 }
 226             }
 227             TestCase.fail("Expected property " + Arrays.toString(expectedProps.toArray())
 228                     + " was not found.");
 229         }
 230     }
 231
 232     private void verifyNode(final String propName, final PropertyNode actualNode) {
 233         final List<PropertyNode> expectedNodeList = mOrderedNodeMap.get(propName);
 234         final int size = (expectedNodeList != null ? expectedNodeList.size() : 0);
 235         if (size > 0) {
 236             for (int i = 0; i < size; i++) {
 237                 final PropertyNode expectedNode = expectedNodeList.get(i);
 238                 final List<PropertyNode> expectedButDifferentValueList =
 239                         new ArrayList<PropertyNode>();
 240                 if (expectedNode.propName.equals(propName)) {
 241                     if (expectedNode.equals(actualNode)) {
 242                         expectedNodeList.remove(i);
 243                         if (expectedNodeList.size() == 0) {
 244                             mOrderedNodeMap.remove(propName);
 245                         }
 246                         return;
 247                     } else {
 248                         expectedButDifferentValueList.add(expectedNode);
 249                     }
 250                 }
 251
 252                 // "actualNode" is not in ordered expected list.
 253                 // Try looking over unordered expected list.
 254                 if (tryFoundExpectedNodeFromUnorderedList(actualNode,
 255                         expectedButDifferentValueList)) {
 256                     return;
 257                 }
 258
 259                 if (!expectedButDifferentValueList.isEmpty()) {
 260                     // Same propName exists but with different value(s).
 261                     failWithExpectedNodeList(propName, actualNode,
 262                             expectedButDifferentValueList);
 263                 } else {
 264                     // There's no expected node with same propName.
 265                     TestCase.fail("Unexpected property \"" + propName + "\" exists.");
 266                 }
 267             }
 268         } else {
 269             List<PropertyNode> expectedButDifferentValueList =
 270                 new ArrayList<PropertyNode>();
 271             if (tryFoundExpectedNodeFromUnorderedList(actualNode, expectedButDifferentValueList)) {
 272                 return;
 273             } else {
 274                 if (!expectedButDifferentValueList.isEmpty()) {
 275                     // Same propName exists but with different value(s).
 276                     failWithExpectedNodeList(propName, actualNode,
 277                             expectedButDifferentValueList);
 278                 } else {
 279                     // There's no expected node with same propName.
 280                     TestCase.fail("Unexpected property \"" + propName + "\" exists.");
 281                 }
 282             }
 283         }
 284     }
 285
 286     private String concatinateListWithSemiColon(List<String> array) {
 287         StringBuffer buffer = new StringBuffer();
 288         boolean first = true;
 289         for (String propValueElem : array) {
 290             if (first) {
 291                 first = false;
 292             } else {
 293                 buffer.append(';');
 294             }
 295             buffer.append(propValueElem);
 296         }
 297
 298         return buffer.toString();
 299     }
 300
 301     private boolean tryFoundExpectedNodeFromUnorderedList(PropertyNode actualNode,
 302             List<PropertyNode> expectedButDifferentValueList) {
 303         final String propName = actualNode.propName;
 304         int unorderedListSize = mUnorderedNodeList.size();
 305         for (int i = 0; i < unorderedListSize; i++) {
 306             PropertyNode unorderedExpectedNode = mUnorderedNodeList.get(i);
 307             if (unorderedExpectedNode.propName.equals(propName)) {
 308                 if (unorderedExpectedNode.equals(actualNode)) {
 309                     mUnorderedNodeList.remove(i);
 310                     return true;
 311                 }
 312                 expectedButDifferentValueList.add(unorderedExpectedNode);
 313             }
 314         }
 315         return false;
 316     }
 317
 318     private void failWithExpectedNodeList(String propName, PropertyNode actualNode,
 319             List<PropertyNode> expectedNodeList) {
 320         StringBuilder builder = new StringBuilder();
 321         for (PropertyNode expectedNode : expectedNodeList) {
 322             builder.append("expected: ");
 323             builder.append(expectedNode.toString());
 324             builder.append("\n");
 325         }
 326         TestCase.fail("Property \"" + propName + "\" has wrong value.\n"
 327                 + builder.toString()
 328                 + "  actual: " + actualNode.toString());
 329     }
 330 }