binding/mdsal-binding-generator/src/test/java/org/opendaylight/mdsal/binding/generator/impl/SupportTestUtil.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.binding.generator.impl;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertTrue;
  12
  13 import java.util.List;
  14 import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
  15 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
  16 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
  17 import org.opendaylight.mdsal.binding.model.api.MethodSignature;
  18 import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
  19 import org.opendaylight.mdsal.binding.model.api.Type;
  20
  21 public final class SupportTestUtil {
  22     private SupportTestUtil() {
  23
  24     }
  25
  26     public static void containsMethods(final GeneratedType genType, final NameTypePattern... searchedSignsWhat) {
  27         final List<MethodSignature> searchedSignsIn = genType.getMethodDefinitions();
  28         containsMethods(searchedSignsIn, searchedSignsWhat);
  29     }
  30
  31     public static void containsMethods(final List<MethodSignature> searchedSignsIn,
  32             final NameTypePattern... searchedSignsWhat) {
  33         if (searchedSignsIn == null) {
  34             throw new IllegalArgumentException("List of method signatures in which should be searched can't be null");
  35         }
  36         if (searchedSignsWhat == null) {
  37             throw new IllegalArgumentException("Array of method signatures which should be searched can't be null");
  38         }
  39
  40         for (NameTypePattern searchedSignWhat : searchedSignsWhat) {
  41             boolean nameMatchFound = false;
  42             String typeNameFound = "";
  43             for (MethodSignature searchedSignIn : searchedSignsIn) {
  44                 if (searchedSignWhat.getName().equals(searchedSignIn.getName())) {
  45                     nameMatchFound = true;
  46                     typeNameFound = resolveFullNameOfReturnType(searchedSignIn.getReturnType());
  47                     if (searchedSignWhat.getType().equals(typeNameFound)) {
  48                         break;
  49                     }
  50                 }
  51             }
  52             assertTrue("Method " + searchedSignWhat.getName() + " wasn't found.", nameMatchFound);
  53             assertEquals("Return type in method " + searchedSignWhat.getName() + " doesn't match expected type ",
  54                     searchedSignWhat.getType(), typeNameFound);
  55
  56         }
  57     }
  58
  59     public static void containsAttributes(final GeneratedTransferObject genTO, final boolean equal, final boolean hash,
  60             final boolean toString, final NameTypePattern... searchedSignsWhat) {
  61         List<GeneratedProperty> searchedPropertiesIn = genTO.getProperties();
  62         containsAttributes(searchedPropertiesIn, "", searchedSignsWhat);
  63         if (equal) {
  64             searchedPropertiesIn = genTO.getEqualsIdentifiers();
  65             containsAttributes(searchedPropertiesIn, "equal", searchedSignsWhat);
  66         }
  67         if (hash) {
  68             searchedPropertiesIn = genTO.getHashCodeIdentifiers();
  69             containsAttributes(searchedPropertiesIn, "hash", searchedSignsWhat);
  70         }
  71         if (toString) {
  72             searchedPropertiesIn = genTO.getToStringIdentifiers();
  73             containsAttributes(searchedPropertiesIn, "toString", searchedSignsWhat);
  74         }
  75
  76     }
  77
  78     public static void containsAttributes(final List<GeneratedProperty> searchedPropertiesIn, final String listType,
  79             final NameTypePattern... searchedPropertiesWhat) {
  80
  81         for (NameTypePattern searchedPropertyWhat : searchedPropertiesWhat) {
  82             boolean nameMatchFound = false;
  83             String typeNameFound = "";
  84             for (GeneratedProperty searchedPropertyIn : searchedPropertiesIn) {
  85                 if (searchedPropertyWhat.getName().equals(searchedPropertyIn.getName())) {
  86                     nameMatchFound = true;
  87                     typeNameFound = resolveFullNameOfReturnType(searchedPropertyIn.getReturnType());
  88                     if (searchedPropertyWhat.getType().equals(typeNameFound)) {
  89                         break;
  90                     }
  91                 }
  92             }
  93             assertTrue("Property " + searchedPropertyWhat.getName() + " wasn't found in " + listType
  94                     + " property list.", nameMatchFound);
  95             assertEquals("The type of property " + searchedPropertyWhat.getName() + " in " + listType
  96                     + " property list doesn't match expected type.", searchedPropertyWhat.getType(), typeNameFound);
  97
  98         }
  99     }
 100
 101     public static String resolveFullNameOfReturnType(final Type type) {
 102         final StringBuilder nameBuilder = new StringBuilder();
 103         if (type instanceof ParameterizedType) {
 104             nameBuilder.append(type.getName()).append('<');
 105             ParameterizedType parametrizedTypes = (ParameterizedType) type;
 106             for (Type parametrizedType : parametrizedTypes.getActualTypeArguments()) {
 107                 nameBuilder.append(parametrizedType.getName()).append(',');
 108             }
 109             if (nameBuilder.charAt(nameBuilder.length() - 1) == ',') {
 110                 nameBuilder.deleteCharAt(nameBuilder.length() - 1);
 111             }
 112             nameBuilder.append(">");
 113         } else {
 114             nameBuilder.append(type.getName());
 115         }
 116         return nameBuilder.toString();
 117     }
 118
 119     public static void containsInterface(final String interfaceNameSearched, final GeneratedType genType) {
 120         List<Type> caseCImplements = genType.getImplements();
 121         boolean interfaceFound = false;
 122         for (Type caseCImplement : caseCImplements) {
 123             String interfaceName = resolveFullNameOfReturnType(caseCImplement);
 124             if (interfaceName.equals(interfaceNameSearched)) {
 125                 interfaceFound = true;
 126                 break;
 127             }
 128         }
 129         assertTrue("Generated type " + genType.getName() + " doesn't implement interface " + interfaceNameSearched,
 130                 interfaceFound);
 131     }
 132
 133 }