public void apply()
     throws IllegalAccessException, InvocationTargetException, InstantiationException {
   if (type.isEnum()) {
     for (T instance : type.getEnumConstants()) {
       assertThat(
           instance.toString(),
           is(
               type.getCanonicalName().substring(type.getPackage().getName().length() + 1)
                   + "."
                   + ((Enum<?>) instance).name()));
     }
     return;
   }
   for (Constructor<?> constructor : type.getDeclaredConstructors()) {
     if (constructor.isSynthetic() && skipSynthetic) {
       continue;
     }
     constructor.setAccessible(true);
     Class<?>[] parameterTypes = constructor.getParameterTypes();
     Object[] actualArguments = new Object[parameterTypes.length];
     Object[] otherArguments = new Object[parameterTypes.length];
     int index = 0;
     for (Class<?> parameterType : parameterTypes) {
       putInstance(parameterType, actualArguments, otherArguments, index++);
     }
     int testIndex = 0;
     @SuppressWarnings("unchecked")
     T instance = (T) constructor.newInstance(actualArguments);
     assertThat(instance, is(instance));
     assertThat(instance, not(is((Object) null)));
     assertThat(instance, not(is(new Object())));
     Object similarInstance = constructor.newInstance(actualArguments);
     assertThat(instance.hashCode(), is(similarInstance.hashCode()));
     assertThat(instance, is(similarInstance));
     if (skipToString) {
       assertThat(instance.toString(), notNullValue());
     } else if (optionalToStringRegex == null) {
       checkString(instance);
     } else {
       assertThat(instance.toString(), new RegexMatcher(optionalToStringRegex));
     }
     for (Object otherArgument : otherArguments) {
       Object[] compareArguments = new Object[actualArguments.length];
       int argumentIndex = 0;
       for (Object actualArgument : actualArguments) {
         if (argumentIndex == testIndex) {
           compareArguments[argumentIndex] = otherArgument;
         } else {
           compareArguments[argumentIndex] = actualArgument;
         }
         argumentIndex++;
       }
       Object unlikeInstance = constructor.newInstance(compareArguments);
       assertThat(instance.hashCode(), not(is(unlikeInstance)));
       assertThat(instance, not(is(unlikeInstance)));
       testIndex++;
     }
   }
 }
  @Override
  public String describe() {
    List<String> returns = Lists.newArrayList();
    for (T r : values) returns.add(r.toString());

    return "{" + Joiner.on(',').join(returns) + "}";
  }
Ejemplo n.º 3
0
 public static <T> List<String> toStringList(T[] array) {
   List<String> list = new ArrayList();
   for (T element : array) {
     list.add(element.toString());
   }
   return list;
 }
 private void checkString(T instance) {
   assertThat(
       instance.toString(),
       CoreMatchers.startsWith(
           type.getCanonicalName().substring(type.getPackage().getName().length() + 1) + "{"));
   assertThat(instance.toString(), endsWith("}"));
   Class<?> currentType = type;
   do {
     for (Field field : type.getDeclaredFields()) {
       if (!field.isSynthetic()
           && !Modifier.isStatic(field.getModifiers())
           && !ignoredFields.contains(field.getName())) {
         assertThat(instance.toString(), containsString(field.getName()));
       }
     }
   } while ((currentType = currentType.getSuperclass()) != Object.class);
 }
Ejemplo n.º 5
0
  public static <T> String fmtList(final List<T> list) {
    String result = "";

    for (T item : list) {
      result += item.toString() + "\n";
    }

    return result;
  }
Ejemplo n.º 6
0
 <T> String toString(Iterable<T> items, String sep) {
   String currSep = "";
   StringBuilder sb = new StringBuilder();
   for (T item : items) {
     sb.append(currSep);
     sb.append(item.toString());
     currSep = sep;
   }
   return sb.toString();
 }
Ejemplo n.º 7
0
 /**
  * Computes the display string for any value.
  *
  * @param t the value to print
  * @return the formatted string
  */
 public static <T> String print(T t) {
   if (t == null) {
     return "";
   }
   if (conversion.canConvert(t.getClass(), String.class)) {
     return conversion.convert(t, String.class);
   } else {
     return t.toString();
   }
 }
Ejemplo n.º 8
0
  /**
   * Returns a string of the form elt1.toString() [sep elt2.toString() ... sep elt.toString()] for a
   * collection of elti objects (note there's no actual space between sep and the elti elements).
   * Returns "" if collection is empty. If collection contains just elt, then returns elt.toString()
   *
   * @param separator the string to use to separate objects
   * @param objects a collection of objects. the element order is defined by the iterator over
   *     objects
   * @param <T> the type of the objects
   * @return a non-null string
   */
  public static <T> String join(final String separator, final Collection<T> objects) {
    if (objects.isEmpty()) { // fast path for empty collection
      return "";
    } else {
      final Iterator<T> iter = objects.iterator();
      final T first = iter.next();

      if (!iter.hasNext()) // fast path for singleton collections
      return first.toString();
      else { // full path for 2+ collection that actually need a join
        final StringBuilder ret = new StringBuilder(first.toString());
        while (iter.hasNext()) {
          ret.append(separator);
          ret.append(iter.next().toString());
        }
        return ret.toString();
      }
    }
  }
Ejemplo n.º 9
0
 /**
  * Computes the display string for any value, for a specific type.
  *
  * @param desc the field descriptor - custom formatters are extracted from this descriptor.
  * @param t the value to print
  * @return the formatted string
  */
 public static <T> String print(TypeDescriptor desc, T t) {
   if (t == null) {
     return "";
   }
   if (desc != null && conversion.canConvert(desc, TypeDescriptor.valueOf(String.class))) {
     return (String) conversion.convert(t, desc, TypeDescriptor.valueOf(String.class));
   } else if (conversion.canConvert(t.getClass(), String.class)) {
     return conversion.convert(t, String.class);
   } else {
     return t.toString();
   }
 }
Ejemplo n.º 10
0
 public static <T> String collectionToCommaString(Collection<T> list) {
   if (CollectionUtils.isEmpty(list)) return "";
   StringBuffer result = new StringBuffer();
   for (T item : list) {
     if (item != null) {
       result.append(item.toString() + ",");
     }
   }
   if (result.length() >= 1) {
     result.setLength(result.length() - 1);
   }
   return result.toString();
 }
    public <T> void logMany(final PrintStream stream, final Collection<T> list) {
      final String[] a = new String[list.size()];
      int i = 0;

      for (T e : list) {
        a[i++] = e.toString();
      }

      Arrays.sort(a);

      for (String o : a) {
        stream.println(o);
      }
    }
Ejemplo n.º 12
0
 @Override
 public String toString() {
   List<T> ls = new ArrayList<T>(lefts);
   Collections.reverse(ls);
   StringBuffer sb = new StringBuffer();
   sb.append("((");
   for (int i = 0; i < lefts.size(); i++) {
     if (i != 0) sb.append(" ");
     sb.append(lefts.get(i).toString());
   }
   sb.append(") " + current.toString() + " (");
   for (int i = 0; i < rights.size(); i++) {
     if (i != 0) sb.append(" ");
     sb.append(rights.get(i).toString());
   }
   sb.append("))\n");
   return sb.toString();
 }
Ejemplo n.º 13
0
 public static <T> void out(LinkedList<T> list) {
   for (T t : list) {
     System.out.println(t.toString());
   }
 }
 protected String getItemText(@NotNull T value) {
   return value.toString();
 }