OSCHINA-MIRROR/keko-boy-jmockdata

Вот перевод текста на русский язык:

shortNum;
private int integerNum;
private long longNum;
private float floatNum;
private double doubleNum; // Основные типы данных
private Byte byteBoxing;
private Boolean booleanBoxing;
private Character charBoxing;
private Short shortBoxing;
private Integer integerBoxing;
private Long longBoxing;
private Float floatBoxing;
private Double doubleBoxing; // Массивы основных типов данных
private byte[] byteNumArray;
private boolean[] booleanNumArray;
private char[] charNumArray;
private short[] shortNumArray;
private int[] integerNumArray;
private long[] longNumArray;
private float[] floatNumArray;
private double[] doubleNumArray; // Двумерные массивы основных типов данных
private byte[][] byteNumDoubleArray;
private boolean[][] booleanNumDoubleArray;
private char[][] charNumDoubleArray;
private short[][] shortNumDoubleArray;
private int[][] integerNumDoubleArray;
private long[][] longNumDoubleArray;
private float[][] floatNumDoubleArray;
private double[][] doubleNumDoubleArray; // Массивы базовых типов в упаковке
private Byte[] byteBoxingArray;
private Boolean[] booleanBoxingArray;
private Character[] charBoxingArray;
private Short[] shortBoxingArray;
private Integer[] integerBoxingArray;
private Long[] longBoxingArray;
private Float[] floatBoxingArray;
private Double[] doubleBoxingArray; // Двумерные массивы базовых типов в упаковке
private Byte[][] byteBoxingDoubleArray;
private Boolean[][] booleanBoxingDoubleArray;
private Character[][] charBoxingDoubleArray;
private Short[][] shortBoxingDoubleArray;
private Integer[][] integerBoxingDoubleArray;
private Long[][] longBoxingDoubleArray;
private Float[][] floatBoxingDoubleArray;
private Double[][] doubleBoxingDoubleArray; // Другие часто используемые типы данных
private BigDecimal bigDecimal;
private BigInteger bigInteger;
private Date date;
private String string; // Массивы других часто используемых типов данных
private BigDecimal[] bigDecimalArray;
private BigInteger[] bigIntegerArray;
private Date[] dateArray;
private String[] stringArray; // Двумерные массивы других часто используемых типов данных
private BigDecimal[][] bigDecimalDoubleArray;
private BigInteger[][] bigIntegerDoubleArray;
private Date[][] dateDoubleArray;
private String[][] stringDoubleArray; // Списки, множества и карты
private List[] listArray;
private Set[] setArray;
private Map<Integer, String>[] mapArray; // Двумерные списки, множества и карты
private List[][] listDoubleArray;
private Set[][] setDoubleArray;
private Map<Integer, String>[][] mapDoubleArray; // Двумерные списки, множества и карты (внутренние массивы)
private List<Integer[]>[][] listInnerArrayDoubleArray;
private Set<Integer[]>[][] setInnerArrayDoubleArray;
private Map<Integer[], String[]>[][] mapInnerArrayDoubleArray; // Двумерные списки, множества и карты (двумерные внутренние массивы)
private List<Integer[][]>[][] listInnerDoubleArrayDoubleArray;
private Set<Integer[][]>[][] setInnerDoubleArrayDoubleArray;
private Map<Integer[][], String[][]>[][] mapInnerDoubleArrayDoubleArray; // LIST
private List byteBoxingList;
private List booleanBoxingList;
private List charBoxingList;
private List shortBoxingList;
private List integerBoxingList;
private List longBoxingList;
private List floatBoxingList;
private List doubleBoxingList;
private List bigDecimalList;
private List bigIntegerList;
private List dateList;
private List stringList;
private List<List> stringListList;
private List<Set> stringSetList;
private List<Map<Integer, String>> mapList; // Список массивов
private List<Byte[]> byteBoxingArrayList;
private List<Boolean[]> booleanBoxingArrayList;
private List<Character[]> charBoxingArrayList;
private List<Short[]> shortBoxingArrayList;
private List<Integer[]> integerBoxingArrayList;
private List<Long[]> longBoxingArrayList;
private List<Float[]> floatBoxingArrayList;
private List<Double[]> doubleBoxingArrayList;
private List<BigDecimal[]> bigDecimalArrayList;
private List<BigInteger[]> bigIntegerArrayList;
private List<Date[]> dateArrayList;
private List<String[]> stringArrayList; // Двумерный массив LIST
private List<Byte[][]> byteBoxingDoubleArrayList; ``` List<Boolean[][]> booleanBoxingDoubleArrayList; private List<Character[][]> charBoxingDoubleArrayList; private List<Short[][]> shortBoxingDoubleArrayList; private List<Integer[][]> integerBoxingDoubleArrayList; private List<Long[][]> longBoxingDoubleArrayList; private List<Float[][]> floatBoxingDoubleArrayList; private List<Double[][]> doubleBoxingDoubleArrayList; private List<BigDecimal[][]> bigDecimalDoubleArrayList; private List<BigInteger[][]> bigIntegerDoubleArrayList; private List<Date[][]> dateDoubleArrayList; private List<String[][]> stringDoubleArrayList; //SET忽略同List //MAP private Map<String, Integer> basicMap; private Map<String[], Integer> keyArrayMap; private Map<String, Integer[]> valueArrayMap; private Map<String[], Integer[]> keyValueArrayMap; private Map<String[][], Integer[][]> keyValueDoubleArrayMap; private Map<List, Map<String, Integer>> keyListValueMapMap; private Map<List[], Map<String, Integer>[]> keyArrayListValueArrayMapMap; //getter setter省略... }

BasicBean basicBean = JMockData.mock(BasicBean.class);

### 任意类型（LIST,SET,MAP）

```java
@Test
public void testTypeRefrence() {
  Integer integerNum = JMockData.mock(new TypeReference<Integer>(){});
  Integer[] integerArray = JMockData.mock(new TypeReference<Integer[]>(){});
  List<Integer> integerList = JMockData.mock(new TypeReference<List<Integer>>(){});
  List<Integer[]> integerArrayList = JMockData.mock(new TypeReference<List<Integer[]>>(){});
  List<Integer>[] integerListArray = JmockData.mock(new TypeReference<List<Integer>[]>(){});
  List<BasicBean> basicBeanList = JMockData.mock(new TypeReference<List<BasicBean>>(){});
  Map<List<Map<Integer, String[][]>>, Map<Set<String>, Double[]>> some = JMockData.mock(new TypeReference<Map<List<Map<Integer, String[][]>>, Map<Set<String>, Double[]>>>(){});
}

更改随机范围以及排除某些不模拟数据的字段

字段支持三种模式匹配，可快速配置：[FieldWord]、[FieldWord]、[FieldWord]

MockConfig mockConfig = new MockConfig()
        .globalConfig()
        .sizeRange(1,1)
        .charSeed((char) 97, (char) 98)
        .byteRange((byte) 0, Byte.MAX_VALUE)
        .shortRange((short) 0, Short.MAX_VALUE);

    // 某些字段（名等于integerNum的字段、包含float的字段、double开头的字段）配置
    .subConfig("integerNum","*float*","double*")
    .intRange(10, 11)
    .floatRange(1.22f, 1.50f)
    .doubleRange(1.50,1.99);

    // 某个类的某些字段（long开头的字段、date结尾的字段、包含string的字段）配置。
    .subConfig(BasicBean.class,"long*","*date","*string*")
    .longRange(12, 13)
    .dateRange("2018-11-20", "2018-11-30")
    .stringSeed("SAVED", "REJECT", "APPROVED")
    .sizeRange(1,1);

    // 全局配置
    .globalConfig();

    // 排除所有包含list/set/map字符的字段。表达式不区分大小写。
    .excludes("*List*","*Set*","*Map*");

    // 排除所有Array开头/Boxing结尾的字段。表达式不区分大小写。
    .excludes(BasicBean.class,"*Array","Boxing*");

BasicBean basicBean = JMockData.mock(BasicBean.class, mockConfig);

高级特性

设置小数位数

 public void testDecimalScaleMock() {
    MockConfig mockConfig = new MockConfig()
            .doubleRange(-1.1d,9999.99999d)
            .floatRange(-1.11111f,9999.99999f)
            .decimalScale(3) // 设置小数位数为3，默认是2
            .globalConfig();
    JMockData.mock(BigDecimal.class,mockConfig);
  }

根据正则模拟数据

支持\w \W \d \D \s \S

支持[0-9a-zA-Z] [abc123_]

支持{n} {n,} {n,m}

支持 * + . ?

不支持其他，如() ^ $ | \n \t \cx \b \B \f 等等


   /**
    * 根据正则模拟数据
    * 正则优先于其他规则
    */
   @Test
   public void testRegexMock() {
     MockConfig mockConfig = new MockConfig()
                 // 随机段落字符串
                 .stringRegex("I'am a nice man\\.And I'll just scribble the characters, like：[a-z]{2}-[0-9]{2}-[abc123]{2}-\\w{2}-\\d{2}@\\s{1}-\\S{1}\\.?-.");
                 // 邮箱
``` **Циклические зависимости**

```java
public class AXB {
  private BXA BXA;
  private String name;
  //getter setter省略...
}
public class BXA {
  private AXB AXB;
  private String name;
  //getter setter省略...
}
@Test
public void testCircular() {
   AXB axb = JMockData.mock(AXB.class);
   AXB circularAxb = axb.getBXA().getAXB();
   assertSame(axb, circularAxb);
}

Самозависимость

public class SelfRefData {

  private Integer id;
  private String name;
  private SelfRefData parent;
  private Map<SelfRefData, SelfRefData> parentMap;
  private SelfRefData[] parentArray;
  private List<SelfRefData> list;
  private List<SelfRefData[]> listArray;
  private List<List<SelfRefData[]>> listListArray;
  private List<SelfRefData>[] arrayList;

  private SelfRefData[][][] data;
  private Map<SelfRefData, SelfRefData[]> mapArray;
  private Map<SelfRefData, List<SelfRefData>> mapList;
  private Map<SelfRefData, List<SelfRefData[]>> mapListArray;
  //getter setter省略...
}
@Test
public void testSelf() {
   SelfRefData selfRefData = JMockData.mock(SelfRefData.class);
   assertSame(selfRefData.getParent(), selfRefData);
}

Наследование с использованием дженериков

//Определение универсального родительского класса
public class GenericData<A, B, C> {
  private A a;
  private B b;
  private C c;
  private A[] aArray;
  private List<B> bList;
  private Map<A, B> map;
  private List<C>[] cArray;
  private Map<Map<A, B>, List<C>>[] d;
  //getter setter省略...
}

@Test
public void testGenericData() {
    GenericData<Integer, String, BasicBean> genericData = JMockData.mock(new TypeReference<GenericData<Integer, String, BasicBean>>() {});
    assertNotNull(genericData);
  }

Регистрация пользовательского класса Mocker

MockConfig mockConfig = new MockConfig()
            .registerMocker(Mocker mocker, Class<T>... clazzs)