code-generator/binding-generator-impl/src/test/java/org/opendaylight/yangtools/sal/binding/generator/impl/SupportTestUtil.java

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