Java EnhancedRandom类代码示例

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

    Pair<String, ExternalTaskFailureDto> pair = manager.toFailTask(null, new Object());
    Assert.assertNull(pair);

    pair = manager.toFailTask(Command.TASK_NAME, null);
    Assert.assertNull(pair);

    Command command = EnhancedRandom.random(Command.class);
    pair = manager.toFailTask(Command.TASK_NAME, command);

    Assert.assertNotNull(pair);
    Assert.assertNotNull(pair.getKey());
    Assert.assertEquals(command.getId(), pair.getKey());

    Assert.assertNotNull(pair.getValue());
    Assert.assertEquals(command.getWorkerId(), pair.getValue().getWorkerId());
    Assert.assertEquals(command.getErrorMessage(), pair.getValue().getErrorMessage());
    Assert.assertEquals(command.getRetries().intValue(), pair.getValue().getRetries());
    Assert.assertEquals(command.getRetryTimeout(), pair.getValue().getRetryTimeout());
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入依赖的package包/类
@Parameters
public static Iterable<MPD> randomBeans() {
    EnhancedRandom random = new MPDRandomBuilder()
            .constantStringField("segmentAlignment", "true")
            .constantStringField("subsegmentAlignment", "true")
            .constantStringField("lang", "sv")
            .constantStringField("contains", "1")
            .constantStringField("dependencyLevel", "1")
            .randomize(Long.class, (Supplier<Long>) () -> 5L)
            .randomize(PresentationType.class,(Supplier<PresentationType>) () ->
                    RANDOM.nextBoolean() ? PresentationType.STATIC : PresentationType.DYNAMIC)
            .randomize(Descriptor.class, new Supplier<Descriptor>() {
                private final EnhancedRandom random = new EnhancedRandomBuilder().build();
                @Override
                public Descriptor get() {
                    return random.nextObject(GenericDescriptor.class);
                }
            })
            .collectionSizeRange(1, 2)
            .seed(10005)
            .build();

    return () -> Stream.generate(() -> random.nextObject(MPD.class))
            .limit(10).iterator();
}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入依赖的package包/类
@Test
public void testRandomization() {
    logger.debug("Testing random object generation (seed="+seed+")...");

    // TODO In theory, giving the same id should generate the same result, not different ones.
    List<String> potentialClasses = JaxbHelper.getNonNIEMClassNames();
    if( potentialClasses == null || potentialClasses.size() == 0 ){
        Assert.fail("There are no classes which to generate randomly.");
    }
    Random random = new Random(System.currentTimeMillis());
    String className = potentialClasses.get(random.nextInt(potentialClasses.size()));
    logger.info("  Creating sample Class: "+className);
    try {
        Class clz = Class.forName(className);
        // TODO Figure out how to incorporate the seed here.
        Object instance = EnhancedRandom.random(clz);
        assertThat(instance, notNullValue());

        // TODO Any other assertions?

    }catch(Throwable t){
        logger.error("An unexpected error occurred.", t);
        Assert.fail("Unexpected error using randomizer: "+t.toString());
    }

}
 

import io.github.benas.randombeans.api.EnhancedRandom; //导入依赖的package包/类
@Test
public void testCharset() {
    // Given
    Charset charset = StandardCharsets.UTF_8;
    List<Character> letters = filterLetters(collectPrintableCharactersOf(charset));
    EnhancedRandom enhancedRandom = aNewEnhancedRandomBuilder().charset(charset).build();

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

    // Then
    char[] chars = person.getName().toCharArray();
    for (char c : chars) {
        assertThat(letters).contains(c);
    }
}
 

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 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 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 rawCollectionInterfacesShouldBeEmpty() {
    EnhancedRandom enhancedRandom = aNewEnhancedRandom();

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

    assertThat(collectionsBean).isNotNull();

    assertThat(collectionsBean.getCollection()).isEmpty();
    assertThat(collectionsBean.getSet()).isEmpty();
    assertThat(collectionsBean.getSortedSet()).isEmpty();
    assertThat(collectionsBean.getNavigableSet()).isEmpty();
    assertThat(collectionsBean.getList()).isEmpty();
    assertThat(collectionsBean.getQueue()).isEmpty();
    assertThat(collectionsBean.getBlockingQueue()).isEmpty();
    assertThat(collectionsBean.getTransferQueue()).isEmpty();
    assertThat(collectionsBean.getDeque()).isEmpty();
    assertThat(collectionsBean.getBlockingDeque()).isEmpty();
}
 

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 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 rawCollectionClassesShouldBeEmpty() {
    EnhancedRandom enhancedRandom = aNewEnhancedRandom();

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

    assertThat(collectionsBean).isNotNull();

    assertThat(collectionsBean.getArrayList()).isEmpty();
    assertThat(collectionsBean.getLinkedList()).isEmpty();
    assertThat(collectionsBean.getVector()).isEmpty();
    assertThat(collectionsBean.getStack()).isEmpty();
    assertThat(collectionsBean.getHashSet()).isEmpty();
    assertThat(collectionsBean.getLinkedHashSet()).isEmpty();
    assertThat(collectionsBean.getTreeSet()).isEmpty();
    assertThat(collectionsBean.getConcurrentSkipListSet()).isEmpty();
    assertThat(collectionsBean.getArrayBlockingQueue()).isEmpty();
    assertThat(collectionsBean.getLinkedBlockingQueue()).isEmpty();
    assertThat(collectionsBean.getConcurrentLinkedQueue()).isEmpty();
    assertThat(collectionsBean.getLinkedTransferQueue()).isEmpty();
    assertThat(collectionsBean.getPriorityQueue()).isEmpty();
    assertThat(collectionsBean.getPriorityBlockingQueue()).isEmpty();
    assertThat(collectionsBean.getArrayDeque()).isEmpty();
    assertThat(collectionsBean.getLinkedBlockingDeque()).isEmpty();
    assertThat(collectionsBean.getConcurrentLinkedDeque()).isEmpty();
}
 

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

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

    assertThat(collectionsBean).isNotNull();

    assertThat(collectionsBean.getUnboundedWildCardTypedArrayList()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedLinkedList()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedVector()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedStack()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedHashSet()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedLinkedHashSet()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedTreeSet()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedConcurrentSkipListSet()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedArrayBlockingQueue()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedLinkedBlockingQueue()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedConcurrentLinkedQueue()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedLinkedTransferQueue()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedPriorityQueue()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedPriorityBlockingQueue()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedArrayDeque()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedLinkedBlockingDeque()).isEmpty();
    assertThat(collectionsBean.getUnboundedWildCardTypedConcurrentLinkedDeque()).isEmpty();
}