Java EnhancedRandom.nextObject方法代码示例

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void testEnhancedRandomFactoryBeanWithCustomRandomizers() {

    EnhancedRandom enhancedRandom = getEnhancedRandomFromSpringContext("/application-context-with-custom-randomizers.xml");

    // the enhancedRandom managed by spring should be correctly configured
    assertThat(enhancedRandom).isNotNull();

    // the enhancedRandom should generate valid instances
    Foo foo = enhancedRandom.nextObject(Foo.class);

    assertThat(foo).isNotNull();
    assertThat(foo.getName()).isIn(NameRandomizer.NAMES);
    assertThat(foo.getAge()).isEqualTo(10);
    assertThat(foo.getWeight()).isEqualTo(10);
    assertThat(foo.getBar()).isIn(NameRandomizer.NAMES);
    assertThat(foo.getNickName().length()).isLessThanOrEqualTo(3);
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void primitiveArraysShouldBeCorrectlyPopulated() {
    EnhancedRandom enhancedRandom = aNewEnhancedRandom();

    final ArrayBean bean = enhancedRandom.nextObject(ArrayBean.class);

    // primitive types
    assertThat(toObjectArray(bean.getByteArray())).hasOnlyElementsOfType(Byte.class);
    assertThat(toObjectArray(bean.getShortArray())).hasOnlyElementsOfType(Short.class);
    assertThat(toObjectArray(bean.getIntArray())).hasOnlyElementsOfType(Integer.class);
    assertThat(toObjectArray(bean.getLongArray())).hasOnlyElementsOfType(Long.class);
    assertThat(toObjectArray(bean.getFloatArray())).hasOnlyElementsOfType(Float.class);
    assertThat(toObjectArray(bean.getDoubleArray())).hasOnlyElementsOfType(Double.class);
    assertThat(toObjectArray(bean.getCharArray())).hasOnlyElementsOfType(Character.class);
    assertThat(toObjectArray(bean.getBooleanArray())).hasOnlyElementsOfType(Boolean.class);
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void testRandomizationDepth() {
    // Given
    EnhancedRandom enhancedRandom = aNewEnhancedRandomBuilder()
            .randomizationDepth(2)
            .build();

    // When
    Person person = enhancedRandom.nextObject(Person.class);

    // Then
    assertThat(person).isNotNull();
    assertThat(person.getParent()).isNotNull();
    assertThat(person.getParent().getParent()).isNotNull();
    assertThat(person.getParent().getParent().getParent()).isNull();
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void generatedObjectShouldBeAlwaysTheSameForTheSameSeed() {
    // Given
    EnhancedRandom enhancedRandom = aNewEnhancedRandomBuilder().seed(SEED).build();

    String expectedString = "eOMtThyhVNLWUZNRcBaQKxIy";
    Person expectedPerson = buildExpectedPerson();
    int[] expectedInts = buildExpectedInts();

    // When
    String actualString = enhancedRandom.nextObject(String.class);
    Person actualPerson = enhancedRandom.nextObject(Person.class);
    int[] actualInts = enhancedRandom.nextObject(int[].class);

    // Then
    assertThat(actualString).isEqualTo(expectedString);
    assertThat(actualPerson).isEqualTo(expectedPerson);
    assertThat(actualInts).isEqualTo(expectedInts);
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void unboundedWildCardTypedCollectionInterfacesShouldBeEmpty() {
    EnhancedRandom enhancedRandom = aNewEnhancedRandom();

    final WildCardCollectionBean collectionsBean = enhancedRandom.nextObject(WildCardCollectionBean.class);

    assertThat(collectionsBean).isNotNull();

    assertThat(collectionsBean.getUnboundedWildCardTypedCollection()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedSet()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedSortedSet()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedNavigableSet()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedList()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedQueue()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedBlockingQueue()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedTransferQueue()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedDeque()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedBlockingDeque()).isEmpty();
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void testStringLengthRange() {
    // Given
    int minStringLength = 3;
    int maxStringLength = 50;
    EnhancedRandom enhancedRandom = aNewEnhancedRandomBuilder()
            .stringLengthRange(minStringLength, maxStringLength)
            .build();

    // When
    Person person = enhancedRandom.nextObject(Person.class);

    // Then
    assertThat(person.getName().length()).isBetween(minStringLength, maxStringLength);
    assertThat(person.getEmail().length()).isBetween(minStringLength, maxStringLength);
    assertThat(person.getPhoneNumber().length()).isBetween(minStringLength, maxStringLength);
    assertThat(person.getAddress().getCity().length()).isBetween(minStringLength, maxStringLength);
    assertThat(person.getAddress().getCountry().length()).isBetween(minStringLength, maxStringLength);
    assertThat(person.getAddress().getZipCode().length()).isBetween(minStringLength, maxStringLength);
    assertThat(person.getAddress().getStreet().getName().length()).isBetween(minStringLength, maxStringLength);
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void wildcardTypedMapInterfacesShouldBeEmpty() {
    EnhancedRandom enhancedRandom = aNewEnhancedRandom();

    final WildCardMapBean wildCardMapBean = enhancedRandom.nextObject(WildCardMapBean.class);

    assertThat(wildCardMapBean).isNotNull();

    assertThat(wildCardMapBean.getBoundedWildCardTypedMap()).isEmpty();
    assertThat(wildCardMapBean.getUnboundedWildCardTypedMap()).isEmpty();

    assertThat(wildCardMapBean.getBoundedWildCardTypedSortedMap()).isEmpty();
    assertThat(wildCardMapBean.getUnboundedWildCardTypedSortedMap()).isEmpty();

    assertThat(wildCardMapBean.getBoundedWildCardTypedNavigableMap()).isEmpty();
    assertThat(wildCardMapBean.getUnboundedWildCardTypedNavigableMap()).isEmpty();

    assertThat(wildCardMapBean.getBoundedWildCardTypedConcurrentMap()).isEmpty();
    assertThat(wildCardMapBean.getUnboundedWildCardTypedConcurrentMap()).isEmpty();

    assertThat(wildCardMapBean.getBoundedWildCardTypedConcurrentNavigableMap()).isEmpty();
    assertThat(wildCardMapBean.getUnboundedWildCardTypedConcurrentNavigableMap()).isEmpty();
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void customRandomizerShouldBeRegisteredInAllBuiltInstances() {
    enhancedRandomBuilder = aNewEnhancedRandomBuilder();

    FieldDefinition<?, ?> fieldDefinition = field().named("name").ofType(String.class).inClass(Human.class).get();
    enhancedRandomBuilder.randomize(fieldDefinition, randomizer);

    EnhancedRandom enhancedRandom = enhancedRandomBuilder.build();
    Human human = enhancedRandom.nextObject(Human.class);

    assertThat(human.getName()).isEqualTo(NAME);

    EnhancedRandom enhancedRandom2 = enhancedRandomBuilder.build();
    Human human2 = enhancedRandom2.nextObject(Human.class);

    assertThat(human2.getName()).isEqualTo(NAME);
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void customSupplierShouldBeRegisteredInAllBuiltInstances() {
    enhancedRandomBuilder = aNewEnhancedRandomBuilder();

    FieldDefinition<?, ?> fieldDefinition = field().named("name").ofType(String.class).inClass(Human.class).get();
    enhancedRandomBuilder.randomize(fieldDefinition, supplier);

    EnhancedRandom enhancedRandom = enhancedRandomBuilder.build();
    Human human = enhancedRandom.nextObject(Human.class);

    assertThat(human.getName()).isEqualTo(NAME);

    EnhancedRandom enhancedRandom2 = enhancedRandomBuilder.build();
    Human human2 = enhancedRandom2.nextObject(Human.class);

    assertThat(human2.getName()).isEqualTo(NAME);
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void boundedWildCardTypedCollectionInterfacesShouldBeEmpty() {
    EnhancedRandom enhancedRandom = aNewEnhancedRandom();

    final WildCardCollectionBean collectionsBean = enhancedRandom.nextObject(WildCardCollectionBean.class);

    assertThat(collectionsBean).isNotNull();

    assertThat(collectionsBean.getBoundedWildCardTypedCollection()).isEmpty();
    assertThat(collectionsBean.getBoundedWildCardTypedSet()).isEmpty();
    assertThat(collectionsBean.getBoundedWildCardTypedSortedSet()).isEmpty();
    assertThat(collectionsBean.getBoundedWildCardTypedNavigableSet()).isEmpty();
    assertThat(collectionsBean.getBoundedWildCardTypedList()).isEmpty();
    assertThat(collectionsBean.getBoundedWildCardTypedQueue()).isEmpty();
    assertThat(collectionsBean.getBoundedWildCardTypedBlockingQueue()).isEmpty();
    assertThat(collectionsBean.getBoundedWildCardTypedTransferQueue()).isEmpty();
    assertThat(collectionsBean.getBoundedWildCardTypedDeque()).isEmpty();
    assertThat(collectionsBean.getBoundedWildCardTypedBlockingDeque()).isEmpty();
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void typedCollectionInterfacesShouldNotBeEmpty() {
    EnhancedRandom enhancedRandom = aNewEnhancedRandom();

    final CollectionBean collectionsBean = enhancedRandom.nextObject(CollectionBean.class);

    assertThat(collectionsBean).isNotNull();

    assertContainsOnlyNonEmptyPersons(collectionsBean.getTypedCollection());
    assertContainsOnlyNonEmptyPersons(collectionsBean.getTypedSet());
    assertContainsOnlyNonEmptyPersons(collectionsBean.getTypedSortedSet());
    assertContainsOnlyNonEmptyPersons(collectionsBean.getTypedNavigableSet());
    assertContainsOnlyNonEmptyPersons(collectionsBean.getTypedList());
    assertContainsOnlyNonEmptyPersons(collectionsBean.getTypedQueue());
    assertContainsOnlyNonEmptyPersons(collectionsBean.getTypedBlockingQueue());
    assertContainsOnlyNonEmptyPersons(collectionsBean.getTypedTransferQueue());
    assertContainsOnlyNonEmptyPersons(collectionsBean.getTypedDeque());
    assertContainsOnlyNonEmptyPersons(collectionsBean.getTypedBlockingDeque());
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void userDefinedMapTypeShouldBePopulated() throws Exception {
    EnhancedRandom enhancedRandom = aNewEnhancedRandom();

    CustomMap customMap = enhancedRandom.nextObject(CustomMap.class);

    assertThat(customMap).isNotNull();
    assertThat(customMap.getName()).isNotNull();
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void whenOverrideDefaultInitializationParameterIsTrue_thenShouldRandomizeFields() {
    // Given
    EnhancedRandom enhancedRandom = aNewEnhancedRandomBuilder().overrideDefaultInitialization(true).build();

    // When
    BeanWithDefaultFieldValues bean = enhancedRandom.nextObject(BeanWithDefaultFieldValues.class);

    // Then
    assertThat(bean.getDefaultNonNullValue()).isNotEqualTo("default").isNotNull();
    assertThat(bean.getDefaultNonNullValueSetByConstructor()).isNotEqualTo("defaultSetByConstructor").isNotNull();
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void enumMapTypeShouldBePopulated() throws Exception {
    EnhancedRandom enhancedRandom = aNewEnhancedRandom();

    EnumMapBean enumMapBean = enhancedRandom.nextObject(EnumMapBean.class);

    assertThat(enumMapBean).isNotNull();
    assertThat(enumMapBean.getTypedEnumMap()).isNotNull();
    assertThat(enumMapBean.getUntypedEnumMap()).isNull();
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入方法依赖的package包/类
@Test
public void compositeCollectionTypesShouldBeEmpty() {
    EnhancedRandom enhancedRandom = aNewEnhancedRandom();

    CompositeCollectionBean compositeCollectionBean = enhancedRandom.nextObject(CompositeCollectionBean.class);

    assertThat(compositeCollectionBean.getListOfLists()).isEmpty();
    assertThat(compositeCollectionBean.getTypedListOfLists()).isEmpty();
    assertThat(compositeCollectionBean.getSetOfSets()).isEmpty();
    assertThat(compositeCollectionBean.getTypedSetOfSets()).isEmpty();
    assertThat(compositeCollectionBean.getQueueOfQueues()).isEmpty();
    assertThat(compositeCollectionBean.getTypedQueueOdQueues()).isEmpty();
}