autofixture.publicinterface.Any Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of autofixturegenerator Show documentation
An attempt to reimplement core features of a popular .NET anonymous value generator - AutoFixture - in Java
There is a newer version: 2.1.10
package autofixture.publicinterface;

import autofixture.interfaces.InlineConstrainedGenerator;
import autofixture.interfaces.InlineInstanceGenerator;
import lombok.NonNull;

import java.net.InetAddress;
import java.net.URI;
import java.net.URL;
import java.time.*;
import java.time.chrono.ChronoLocalDate;
import java.time.chrono.ChronoLocalDateTime;
import java.util.*;

public class Any {

  @NonNull
  public static  T anonymous(final InstanceOf instanceType) {
    return Generate.any(instanceType);
  }

  @NonNull
  public static  T anonymous(final Class clazz) {
    return Generate.any(clazz);
  }

  @NonNull
  public static  T instanceOf(final Class clazz) {
    return Generate.any(clazz);
  }

  @NonNull
  public static  T anonymous(final InlineInstanceGenerator generator) {
    return Generate.any(generator);
  }

  @NonNull
  public static  T anonymous(final InstanceOf type, final InlineConstrainedGenerator generator) {
    return Generate.any(type, generator);
  }

  @NonNull
  public static  T anonymous(final Class instanceType, final InlineConstrainedGenerator generator) {
    return Generate.any(instanceType, generator);
  }

  @NonNull
  public static  T dummy(final InstanceOf instanceType) {
    return Generate.dummy(instanceType);
  }

  @NonNull
  public static  T dummy(final Class clazz) {
    return Generate.dummy(clazz);
  }

  public static String string() {
    return Generate.anyString();
  }

  @NonNull
  public static String string(String seed) {
    return Generate.anyString(seed);
  }

  public static String string(final int charactersCount) {
    return stringOfLength(charactersCount);
  }

  public static String stringOfLength(final int charactersCount) {
    return Generate.anyStringOfLength(charactersCount);
  }

  @NonNull
  public static String stringNotContaining(final String... excludedSubstrings) {
    return Generate.anyStringNotContaining(excludedSubstrings);
  }

  @NonNull
  public static String stringContaining(final String str) {
    return Generate.anyStringContaining(str);
  }

  public static Character alphaChar() {
    return Generate.anyAlphaChar();
  }

  public static Character digitChar() {
    return Generate.anyDigitChar();
  }

  public static String alphaString() {
    return Generate.anyAlphaString();
  }

  public static String alphaString(final int length) {
    return Generate.anyAlphaString(length);
  }

  public static String lowercaseString() {
    return Generate.anyLowercaseString();
  }

  public static String lowercaseString(final int length) {
    return Generate.anyLowercaseString(length);
  }


  public static String uppercaseString() {
    return Generate.anyUppercaseString();
  }
  public static String uppercaseString(final int length) {
    return Generate.anyUppercaseString(length);
  }


  public static String identifier() {
    return Generate.anyIdentifier();
  }

  public static String legalXmlTagName() {
    return Generate.anyLegalXmlTagName();
  }

  public static Integer intValue() {
    return Generate.anyInteger();
  }

  public static Short shortValue() {
    return Generate.anyShort();
  }

  public static Double doubleValue() {
    return Generate.anyDouble();
  }

  public static Float floatValue() {
    return Generate.anyFloat();
  }

  public static Character charValue() {
    return Generate.anyChar();
  }

  public static Long longValue() {
    return Generate.anyLong();
  }

  @NonNull
  public static  T otherThan(final T... others) {
    //todo doesn't work for generics
    return Any.anonymous((Class) others[0].getClass(), InlineGenerators.otherThan(others));
  }

  @NonNull
  public static Long longOtherThan(final long... other) {
    return Generate.anyLongOtherThan(other);
  }

  @NonNull
  public static String stringOtherThan(final String... other) {
    return Generate.anyStringOtherThan(other);
  }

  @NonNull
  public static Integer intOtherThan(final int... other) {
    return Generate.anyIntegerOtherThan(other);
  }

  @NonNull
  public static Short shortOtherThan(final short... other) {
    return Generate.anyShortOtherThan(other);
  }

  @NonNull
  public static Double doubleOtherThan(final double... other) {
    return Generate.anyDoubleOtherThan(other);
  }

  @NonNull
  public static Float floatOtherThan(final float... other) {
    return Generate.anyFloatOtherThan(other);
  }

  @NonNull
  public static  T of(final Class enumClass) {
    return Generate.anyOf(enumClass);
  }

  public static Date date() {
    return Generate.anyDate();
  }

  @NonNull
  public static  T exploding(final Class clazz) {
    return Generate.anyExploding(clazz);
  }

  @NonNull
  public static  T exploding(final InstanceOf typeToken) {
    return Generate.anyExploding(typeToken);
  }

  public static Exception exception() {
    return Generate.anyException();
  }

  public static RuntimeException runtimeException() {
    return Generate.anyRuntimeException();
  }

  public static Exception checkedException() {
    return Generate.anyCheckedException();
  }

  public static Throwable throwable() {
    return Generate.anyThrowable();
  }

  public static Throwable uncheckedThrowable() {
    return runtimeException();
  }


  public static Error error() {
    return Generate.anyError();
  }

  public static Boolean booleanValue() {
    return Generate.anyBoolean();
  }

  public static Object object() {
    return Generate.any(Object.class);
  }

  public static URI uri() {
    return Generate.anyUri();
  }

  public static URL url() {
    return Generate.anyUrl();
  }

  public static int port() {
    return Generate.anyPort();
  }

  public static InetAddress ip() {
    return Generate.anyIp();
  }

  public static ChronoLocalDate chronoLocalDate() {
    return Generate.anyChronoLocalDate();
  }

  public static ChronoLocalDateTime chronoLocalDateTime() {
    return Generate.anyChronoLocalDateTime();
  }

  public static LocalDateTime localDateTime() {
    return Generate.anyLocalDateTime();
  }

  public static LocalDate localDate() {
    return Generate.anyLocalDate();
  }

  public static ZonedDateTime zonedDateTime() {
    return Generate.anyZonedDateTime();
  }

  public static ZoneId zoneId() {
    return Generate.anyZoneId();
  }

  public static OffsetTime offsetTime() {
    return Generate.anyOffsetTime();
  }

  public static Period period() {
    return Generate.anyPeriod();
  }

  public static Duration duration() {
    return Generate.anyDuration();
  }

  public static ZoneOffset zoneOffset() {
    return Generate.anyZoneOffset();
  }

  public static Clock clock() {
    return Generate.anyClock();
  }

  public static Instant instant() {
    return Generate.anyInstant();
  }

  @NonNull
  public static  T from(final T... possibleValues) {
    return Generate.anyFrom(possibleValues);
  }


  // ITERABLES - complete
  @NonNull
  public static  Iterable iterableOf(final InstanceOf type) {
    return Generate.manyAsIterableOf(type);
  }

  @NonNull
  public static  Iterable iterableOf(final Class clazz) {
    return Generate.manyAsIterableOf(clazz);
  }

  @NonNull
  public static  Iterable iterableOf(
      final InstanceOf typeToken, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsIterableOf(typeToken, omittedValues);
  }

  @NonNull
  public static  Iterable iterableOf(final Class type, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsIterableOf(type, omittedValues);
  }

  //ARRAYS - complete
  @NonNull
  public static  T[] arrayOf(final Class clazz) {
    return Generate.manyAsArrayOf(clazz);
  }

  @NonNull
  public static  T[] arrayOf(final InstanceOf type) {
    return Generate.manyAsArrayOf(type);
  }

  @NonNull
  public static  T[] arrayOf(final InstanceOf typeToken, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsArrayOf(typeToken, omittedValues);
  }

  @NonNull
  public static  T[] arrayOf(final Class type, final InlineConstrainedGenerator omittedValues) {
    T[] array = Generate.manyAsArrayOf(type, omittedValues);
    return array;
  }

  //LISTS - complete

  @NonNull
  public static  List listOf(final Class clazz) {
    return Generate.manyAsListOf(clazz);
  }

  @NonNull
  public static  List listOf(final InstanceOf type) {
    return Generate.manyAsListOf(type);
  }

  @NonNull
  public static  List listOf(final InstanceOf typeToken, final InlineConstrainedGenerator generator) {
    return Generate.manyAsListOf(typeToken, generator);
  }

  @NonNull
  public static  List listOf(final Class type, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsListOf(type, omittedValues);
  }

  // COLLECTIONS - complete

  @NonNull
  public static  Collection collectionOf(final InstanceOf typeToken, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsCollectionOf(typeToken, omittedValues);
  }

  @NonNull
  public static  Collection collectionOf(final Class type, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsCollectionOf(type, omittedValues);
  }

  @NonNull
  public static  Collection collectionOf(final Class clazz) {
    return Generate.manyAsCollectionOf(clazz);
  }

  @NonNull
  public static  Collection collectionOf(final InstanceOf instanceType) {
    return Generate.manyAsCollectionOf(instanceType);
  }

  //SETS: incomplete

  //TODO variations
  @NonNull
  public static  Set setOf(final Class clazz) {
    return Generate.manyAsSetOf(clazz);
  }

  @NonNull
  public static  Set setOf(final InstanceOf type) {
    return Generate.manyAsSetOf(type);
  }

  //TODO UT
  @NonNull
  public static  Set setOf(final Class type, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsSetOf(type, omittedValues);
  }

  //TODO UT
  @NonNull
  public static  Set setOf(final InstanceOf type, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsSetOf(type, omittedValues);
  }


  //queues: incomplete
  @NonNull
  public static  Queue queueOf(final Class clazz) {
    return Generate.manyAsQueueOf(clazz);
  }

  @NonNull
  public static  Queue queueOf(final InstanceOf type) {
    return Generate.manyAsQueueOf(type);
  }

  //TODO UT
  @NonNull
  public static  Queue queueOf(final Class type, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsQueueOf(type, omittedValues);
  }

  //TODO UT
  @NonNull
  public static  Queue queueOf(final InstanceOf type, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsQueueOf(type, omittedValues);
  }

  //Deques: incomplete
  @NonNull
  public static  Deque dequeOf(final Class clazz) {
    return Generate.manyAsDequeOf(clazz);
  }

  @NonNull
  public static  Deque dequeOf(final InstanceOf type) {
    return Generate.manyAsDequeOf(type);
  }

  //TODO UT
  @NonNull
  public static  Deque dequeOf(final Class type, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsDequeOf(type, omittedValues);
  }

  //TODO UT
  @NonNull
  public static  Deque dequeOf(final InstanceOf type, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsDequeOf(type, omittedValues);
  }

  //sorted sets: incomplete
  @NonNull
  public static  SortedSet sortedSetOf(final Class clazz) {
    return Generate.manyAsSortedSetOf(clazz);
  }

  @NonNull
  public static  SortedSet sortedSetOf(final InstanceOf type) {
    return Generate.manyAsSortedSetOf(type);
  }

  //TODO UT
  @NonNull
  public static  SortedSet sortedSetOf(final Class type, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsSortedSetOf(type, omittedValues);
  }

  //TODO UT
  @NonNull
  public static  SortedSet sortedSetOf(final InstanceOf type, final InlineConstrainedGenerator omittedValues) {
    return Generate.manyAsSortedSetOf(type, omittedValues);
  }

  //sorted maps

  //TODO variations and UT
  @NonNull
  public static  SortedMap sortedMapBetween(final Class key, final Class value) {
    return Generate.manyAsSortedMapBetween(key, value);
  }

  @NonNull
  public static  SortedMap sortedMapBetween(final InstanceOf key, final InstanceOf value) {
    return Generate.manyAsSortedMapBetween(key, value);
  }

  //maps

  //TODO variations
  @NonNull
  public static  Map mapBetween(final Class keyClass, final Class valueClass) {
    return Generate.manyAsMapBetween(keyClass, valueClass);
  }

  @NonNull
  public static  Map mapBetween(final InstanceOf keyType, final InstanceOf valueType) {
    return Generate.manyAsMapBetween(keyType, valueType);
  }


}