lib.Randoms.blocks()

Here are the examples of the java api lib.Randoms.blocks() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

27 Examples 7

16 Source : ReadOnlyListPiecesTest.java
with MIT License
from knewjade

@Test
void equalToLongPieces() throws Exception {
    Randoms randoms = new Randoms();
    for (int count = 0; count < 10000; count++) {
        int size = randoms.nextIntOpen(1, 22);
        List<Piece> pieces = randoms.blocks(size);
        Pieces readOnlyListPieces = new ReadOnlyListPieces(pieces);
        LongPieces longPieces = new LongPieces(pieces);
        replacedertThat(readOnlyListPieces.equals(longPieces)).as(longPieces.getPieces().toString()).isTrue();
    }
}

16 Source : ReadOnlyListPiecesTest.java
with MIT License
from knewjade

@Test
void createRandomStream() throws Exception {
    Randoms randoms = new Randoms();
    for (int count = 0; count < 10000; count++) {
        int size = randoms.nextIntOpen(1, 22);
        List<Piece> blocks = randoms.blocks(size);
        Pieces pieces = new ReadOnlyListPieces(blocks);
        replacedertThat(pieces.getPieces()).isEqualTo(blocks);
    }
}

16 Source : ReadOnlyListPiecesTest.java
with MIT License
from knewjade

@Test
void createRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int count = 0; count < 10000; count++) {
        int size = randoms.nextIntOpen(1, 22);
        List<Piece> blocks = randoms.blocks(size);
        Pieces pieces = new ReadOnlyListPieces(blocks);
        replacedertThat(pieces.getPieces()).isEqualTo(blocks);
    }
}

16 Source : LongPiecesTest.java
with MIT License
from knewjade

@Test
void equalToReadOnlyPieces() throws Exception {
    Randoms randoms = new Randoms();
    for (int count = 0; count < 10000; count++) {
        int size = randoms.nextIntOpen(1, 22);
        List<Piece> pieces = randoms.blocks(size);
        LongPieces longPieces = new LongPieces(pieces);
        Pieces readOnlyListPieces = new ReadOnlyListPieces(pieces);
        replacedertThat(longPieces.equals(readOnlyListPieces)).as(longPieces.getPieces().toString()).isTrue();
    }
}

16 Source : LongPiecesTest.java
with MIT License
from knewjade

@Test
void createRandomSize22() throws Exception {
    Randoms randoms = new Randoms();
    for (int count = 0; count < 10000; count++) {
        List<Piece> blocks = randoms.blocks(22);
        Pieces pieces = new LongPieces(blocks);
        replacedertThat(pieces.blockStream()).containsExactlyElementsOf(blocks);
        replacedertThat(pieces.getPieces()).isEqualTo(blocks);
    }
}

15 Source : OrderLookupTest.java
with MIT License
from knewjade

@Test
void reverseJustBlocksRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 1; size <= 13; size++) {
        List<Piece> pieceList = randoms.blocks(size);
        int fromDepth = pieceList.size();
        PiecesNumberComparator comparator = new PiecesNumberComparator();
        List<LongPieces> forward1 = OrderLookup.reverseBlocks(pieceList, fromDepth).stream().map(StackOrder::toList).map(LongPieces::new).sorted(comparator).collect(Collectors.toList());
        ReverseOrderLookUp lookUp = new ReverseOrderLookUp(pieceList.size(), fromDepth);
        List<LongPieces> forward2 = lookUp.parse(pieceList).map(blockStream -> blockStream.collect(Collectors.toList())).map(LongPieces::new).sorted(comparator).collect(Collectors.toList());
        replacedertThat(forward2).isEqualTo(forward1);
    }
}

15 Source : OrderLookupTest.java
with MIT License
from knewjade

@Test
void forwardOverBlocksRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 3; size <= 13; size++) {
        List<Piece> pieceList = randoms.blocks(size);
        int toDepth = pieceList.size() - 1;
        PiecesNumberComparator comparator = new PiecesNumberComparator();
        List<LongPieces> forward1 = OrderLookup.forwardBlocks(pieceList, toDepth).stream().map(StackOrder::toList).map(LongPieces::new).sorted(comparator).collect(Collectors.toList());
        ForwardOrderLookUp lookUp = new ForwardOrderLookUp(toDepth, pieceList.size());
        List<LongPieces> forward2 = lookUp.parse(pieceList).map(blockStream -> blockStream.collect(Collectors.toList())).map(LongPieces::new).sorted(comparator).collect(Collectors.toList());
        replacedertThat(forward2).isEqualTo(forward1);
    }
}

15 Source : OrderLookupTest.java
with MIT License
from knewjade

@Test
void reverseOver2BlocksRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 1; size <= 13; size++) {
        List<Piece> pieceList = randoms.blocks(size);
        int fromDepth = pieceList.size() + 2;
        Comparator<List<Piece>> comparator = new ListComparator<>(Comparator.nullsFirst(Comparator.comparingInt(Piece::getNumber)));
        List<List<Piece>> forward1 = OrderLookup.reverseBlocks(pieceList, fromDepth).stream().map(StackOrder::toList).sorted(comparator).collect(Collectors.toList());
        ReverseOrderLookUp lookUp = new ReverseOrderLookUp(pieceList.size(), fromDepth);
        List<List<Piece>> forward2 = lookUp.parse(pieceList).map(blockStream -> blockStream.collect(Collectors.toList())).sorted(comparator).collect(Collectors.toList());
        replacedertThat(forward2).isEqualTo(forward1);
    }
}

15 Source : OrderLookupTest.java
with MIT License
from knewjade

@Test
void reverseOverBlocksRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 1; size <= 13; size++) {
        List<Piece> pieceList = randoms.blocks(size);
        int fromDepth = pieceList.size() + 1;
        Comparator<List<Piece>> comparator = new ListComparator<>(Comparator.nullsFirst(Comparator.comparingInt(Piece::getNumber)));
        List<List<Piece>> forward1 = OrderLookup.reverseBlocks(pieceList, fromDepth).stream().map(StackOrder::toList).sorted(comparator).collect(Collectors.toList());
        ReverseOrderLookUp lookUp = new ReverseOrderLookUp(pieceList.size(), fromDepth);
        List<List<Piece>> forward2 = lookUp.parse(pieceList).map(blockStream -> blockStream.collect(Collectors.toList())).sorted(comparator).collect(Collectors.toList());
        replacedertThat(forward2).isEqualTo(forward1);
    }
}

15 Source : OrderLookupTest.java
with MIT License
from knewjade

@Test
void forwardJustBlocksRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 2; size <= 13; size++) {
        List<Piece> pieceList = randoms.blocks(size);
        int toDepth = pieceList.size();
        PiecesNumberComparator comparator = new PiecesNumberComparator();
        List<LongPieces> forward1 = OrderLookup.forwardBlocks(pieceList, toDepth).stream().map(StackOrder::toList).map(LongPieces::new).sorted(comparator).collect(Collectors.toList());
        ForwardOrderLookUp lookUp = new ForwardOrderLookUp(toDepth, pieceList.size());
        List<LongPieces> forward2 = lookUp.parse(pieceList).map(blockStream -> blockStream.collect(Collectors.toList())).map(LongPieces::new).sorted(comparator).collect(Collectors.toList());
        replacedertThat(forward2).isEqualTo(forward1);
    }
}

15 Source : OrderLookupTest.java
with MIT License
from knewjade

@Test
void forwardOver2BlocksRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 4; size <= 13; size++) {
        List<Piece> pieceList = randoms.blocks(size);
        int toDepth = pieceList.size() - 2;
        PiecesNumberComparator comparator = new PiecesNumberComparator();
        List<LongPieces> forward1 = OrderLookup.forwardBlocks(pieceList, toDepth).stream().map(StackOrder::toList).map(LongPieces::new).sorted(comparator).collect(Collectors.toList());
        ForwardOrderLookUp lookUp = new ForwardOrderLookUp(toDepth, pieceList.size());
        List<LongPieces> forward2 = lookUp.parse(pieceList).map(blockStream -> blockStream.collect(Collectors.toList())).map(LongPieces::new).sorted(comparator).collect(Collectors.toList());
        replacedertThat(forward2).isEqualTo(forward1);
    }
}

15 Source : PiecesTest.java
with MIT License
from knewjade

@Test
void testHashCode() throws Exception {
    Randoms randoms = new Randoms();
    for (int count = 0; count < 10000; count++) {
        int size = randoms.nextIntOpen(4, 10);
        List<Piece> pieces = randoms.blocks(size);
        ReadOnlyListPieces readOnlyListPieces = new ReadOnlyListPieces(pieces);
        LongPieces longPieces = new LongPieces(pieces);
        replacedertThat(readOnlyListPieces.hashCode()).as(pieces.toString()).isEqualTo(longPieces.hashCode());
    }
}

14 Source : ReverseOrderLookUpTest.java
with MIT License
from knewjade

@Test
void parseJustRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 2; size <= 13; size++) {
        List<Piece> blocks = randoms.blocks(size);
        int fromDepth = blocks.size();
        ReverseOrderLookUp reverseOrderLookUp = new ReverseOrderLookUp(blocks.size(), fromDepth);
        List<LongPieces> reverse = reverseOrderLookUp.parse(blocks).map(LongPieces::new).collect(Collectors.toList());
        LongPieces target = new LongPieces(blocks);
        ForwardOrderLookUp forwardOrderLookUp = new ForwardOrderLookUp(blocks.size(), fromDepth);
        for (LongPieces pieces : reverse) {
            boolean isFound = forwardOrderLookUp.parse(pieces.getPieces()).map(LongPieces::new).anyMatch(target::equals);
            replacedertThat(isFound).isTrue();
        }
    }
}

14 Source : LongPiecesTest.java
with MIT License
from knewjade

@Test
void createRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int count = 0; count < 10000; count++) {
        ArrayList<Piece> blocks = new ArrayList<>(randoms.blocks(1));
        Pieces pieces = new LongPieces(blocks);
        for (int addCount = 0; addCount < 3; addCount++) {
            List<Piece> newPieces = randoms.blocks(randoms.nextIntOpen(0, 7));
            blocks.addAll(newPieces);
            pieces = pieces.addAndReturnNew(newPieces);
        }
        replacedertThat(pieces.getPieces()).isEqualTo(blocks);
    }
}

14 Source : LongPiecesTest.java
with MIT License
from knewjade

@Test
void createEqualsRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int count = 0; count < 10000; count++) {
        int size1 = randoms.nextIntOpen(1, 21);
        List<Piece> blocks1 = randoms.blocks(size1);
        int size2 = randoms.nextIntOpen(1, 22);
        List<Piece> blocks2 = randoms.blocks(size2);
        if (blocks1.equals(blocks2))
            blocks1.add(Piece.I);
        Pieces pieces1 = new LongPieces(blocks1);
        Pieces pieces2 = new LongPieces(blocks2);
        replacedertThat(pieces1.equals(pieces2)).isFalse();
    }
}

13 Source : PieceInterpreterTest.java
with MIT License
from knewjade

@Test
void parseRandom() {
    Randoms randoms = new Randoms();
    for (int count = 0; count < 10000; count++) {
        int size = randoms.nextIntOpen(1, 100);
        List<Piece> pieces = randoms.blocks(size);
        String name = pieces.stream().map(Piece::getName).collect(Collectors.joining());
        Stream<Piece> stream = BlockInterpreter.parse(name);
        replacedertThat(stream).containsExactlyElementsOf(pieces);
    }
}

12 Source : ReverseOrderLookUpTest.java
with MIT License
from knewjade

@Test
@LongTest
void parseOverRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 2; size <= 13; size++) {
        List<Piece> pieces = randoms.blocks(size);
        int fromDepth = pieces.size() + 1;
        ReverseOrderLookUp reverseOrderLookUp = new ReverseOrderLookUp(pieces.size(), fromDepth);
        List<Stream<Piece>> reverse = reverseOrderLookUp.parse(pieces).collect(Collectors.toList());
        LongPieces target = new LongPieces(pieces);
        ForwardOrderLookUp forwardOrderLookUp = new ForwardOrderLookUp(pieces.size(), fromDepth);
        for (Stream<Piece> stream : reverse) {
            List<Piece> sample = stream.map(block -> block != null ? block : randoms.block()).collect(Collectors.toList());
            boolean isFound = forwardOrderLookUp.parse(sample).map(LongPieces::new).anyMatch(target::equals);
            replacedertThat(isFound).isTrue();
        }
    }
}

12 Source : ReverseOrderLookUpTest.java
with MIT License
from knewjade

@Test
void parseOver2Random() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 2; size <= 12; size++) {
        List<Piece> pieces = randoms.blocks(size);
        int fromDepth = pieces.size() + 2;
        ReverseOrderLookUp reverseOrderLookUp = new ReverseOrderLookUp(pieces.size(), fromDepth);
        List<Stream<Piece>> reverse = reverseOrderLookUp.parse(pieces).collect(Collectors.toList());
        LongPieces target = new LongPieces(pieces);
        ForwardOrderLookUp forwardOrderLookUp = new ForwardOrderLookUp(pieces.size(), fromDepth);
        for (Stream<Piece> stream : reverse) {
            List<Piece> sample = stream.map(block -> block != null ? block : randoms.block()).collect(Collectors.toList());
            boolean isFound = forwardOrderLookUp.parse(sample).map(LongPieces::new).anyMatch(target::equals);
            replacedertThat(isFound).isTrue();
        }
    }
}

12 Source : PieceCounterTest.java
with MIT License
from knewjade

@Test
void testRandom() throws Exception {
    Randoms randoms = new Randoms();
    LOOP: for (int count = 0; count < 10000; count++) {
        List<Piece> pieces = randoms.blocks(randoms.nextIntOpen(0, 500));
        Map<Piece, List<Piece>> group = pieces.stream().collect(Collectors.groupingBy(Function.idenreplacedy()));
        for (List<Piece> eachPiece : group.values()) if (128 <= eachPiece.size())
            continue LOOP;
        PieceCounter pieceCounter = new PieceCounter(pieces);
        EnumMap<Piece, Integer> counterMap = pieceCounter.getEnumMap();
        for (Piece piece : Piece.values()) {
            int expected = group.getOrDefault(piece, Collections.emptyList()).size();
            replacedertThat(counterMap.getOrDefault(piece, 0)).isEqualTo(expected);
        }
    }
}

11 Source : ForwardOrderLookUpTest.java
with MIT License
from knewjade

@Test
void parseOver2BlocksRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 4; size <= 15; size++) {
        List<Piece> pieces = randoms.blocks(size);
        int toDepth = pieces.size();
        ForwardOrderLookUp lookUp = new ForwardOrderLookUp(toDepth - 2, pieces.size());
        HashSet<LongPieces> forward = lookUp.parse(pieces).map(LongPieces::new).collect(Collectors.toCollection(HashSet::new));
        for (int count = 0; count < 10000; count++) {
            ArrayList<Piece> sample = new ArrayList<>();
            int holdIndex = 0;
            for (int index = 1; index < size - 1; index++) {
                if (randoms.nextBoolean(0.3)) {
                    // そのまま追加
                    sample.add(pieces.get(index));
                } else {
                    // ホールドを追加
                    sample.add(pieces.get(holdIndex));
                    holdIndex = index;
                }
            }
            replacedertThat(new LongPieces(sample)).isIn(forward);
        }
    }
}

11 Source : ForwardOrderLookUpTest.java
with MIT License
from knewjade

@Test
void parseOverBlocksRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 3; size <= 15; size++) {
        List<Piece> pieces = randoms.blocks(size);
        int toDepth = pieces.size();
        ForwardOrderLookUp lookUp = new ForwardOrderLookUp(toDepth - 1, pieces.size());
        HashSet<LongPieces> forward = lookUp.parse(pieces).map(LongPieces::new).collect(Collectors.toCollection(HashSet::new));
        for (int count = 0; count < 10000; count++) {
            ArrayList<Piece> sample = new ArrayList<>();
            int holdIndex = 0;
            for (int index = 1; index < size; index++) {
                if (randoms.nextBoolean(0.3)) {
                    // そのまま追加
                    sample.add(pieces.get(index));
                } else {
                    // ホールドを追加
                    sample.add(pieces.get(holdIndex));
                    holdIndex = index;
                }
            }
            replacedertThat(new LongPieces(sample)).isIn(forward);
        }
    }
}

11 Source : ForwardOrderLookUpTest.java
with MIT License
from knewjade

@Test
void parseJustBlocksRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 2; size <= 15; size++) {
        List<Piece> pieces = randoms.blocks(size);
        int toDepth = pieces.size();
        ForwardOrderLookUp lookUp = new ForwardOrderLookUp(toDepth, pieces.size());
        HashSet<LongPieces> forward = lookUp.parse(pieces).map(LongPieces::new).collect(Collectors.toCollection(HashSet::new));
        for (int count = 0; count < 10000; count++) {
            ArrayList<Piece> sample = new ArrayList<>();
            int holdIndex = 0;
            for (int index = 1; index < size; index++) {
                if (randoms.nextBoolean(0.3)) {
                    // そのまま追加
                    sample.add(pieces.get(index));
                } else {
                    // ホールドを追加
                    sample.add(pieces.get(holdIndex));
                    holdIndex = index;
                }
            }
            // ホールドを追加
            sample.add(pieces.get(holdIndex));
            replacedertThat(new LongPieces(sample)).isIn(forward);
        }
    }
}

11 Source : PieceCounterTest.java
with MIT License
from knewjade

@Test
void testContainsAllRandom() throws Exception {
    Randoms randoms = new Randoms();
    LOOP: for (int count = 0; count < 10000; count++) {
        List<Piece> blocks1 = randoms.blocks(randoms.nextIntOpen(0, 500));
        Map<Piece, List<Piece>> group1 = blocks1.stream().collect(Collectors.groupingBy(Function.idenreplacedy()));
        for (List<Piece> eachPiece : group1.values()) if (128 <= eachPiece.size())
            continue LOOP;
        List<Piece> blocks2 = randoms.blocks(randoms.nextIntOpen(0, 500));
        Map<Piece, List<Piece>> group2 = blocks2.stream().collect(Collectors.groupingBy(Function.idenreplacedy()));
        for (List<Piece> eachPiece : group2.values()) if (128 <= eachPiece.size())
            continue LOOP;
        boolean isChild1 = true;
        boolean isChild2 = true;
        List<Piece> empty = Lists.emptyList();
        for (Piece piece : Piece.values()) {
            isChild1 &= group1.getOrDefault(piece, empty).size() <= group2.getOrDefault(piece, empty).size();
            isChild2 &= group2.getOrDefault(piece, empty).size() <= group1.getOrDefault(piece, empty).size();
        }
        PieceCounter counter1 = new PieceCounter(blocks1);
        PieceCounter counter2 = new PieceCounter(blocks2);
        replacedertThat(counter1.containsAll(counter2)).isEqualTo(isChild2);
        replacedertThat(counter2.containsAll(counter1)).isEqualTo(isChild1);
    }
}

10 Source : HoldBreakEnumeratePiecesTest.java
with MIT License
from knewjade

@Test
void enumerateJustRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 3; size <= 15; size++) {
        List<Piece> blocks = randoms.blocks(size);
        String pattern = blocks.stream().map(Piece::getName).collect(Collectors.joining(","));
        PatternGenerator blocksGenerator = new LoadedPatternGenerator(pattern);
        HoldBreakEnumeratePieces core = new HoldBreakEnumeratePieces(blocksGenerator, size);
        Set<LongPieces> pieces = core.enumerate();
        for (int count = 0; count < 10000; count++) {
            ArrayList<Piece> sample = new ArrayList<>();
            int holdIndex = 0;
            for (int index = 1; index < size; index++) {
                if (randoms.nextBoolean(0.3)) {
                    // そのまま追加
                    sample.add(blocks.get(index));
                } else {
                    // ホールドを追加
                    sample.add(blocks.get(holdIndex));
                    holdIndex = index;
                }
            }
            // ホールドを追加
            sample.add(blocks.get(holdIndex));
            replacedertThat(new LongPieces(sample)).isIn(pieces);
        }
    }
}

10 Source : HoldBreakEnumeratePiecesTest.java
with MIT License
from knewjade

@Test
void enumerateOverRandom() throws Exception {
    Randoms randoms = new Randoms();
    for (int size = 3; size <= 15; size++) {
        List<Piece> blocks = randoms.blocks(size);
        String pattern = blocks.stream().map(Piece::getName).collect(Collectors.joining(","));
        PatternGenerator blocksGenerator = new LoadedPatternGenerator(pattern);
        HoldBreakEnumeratePieces core = new HoldBreakEnumeratePieces(blocksGenerator, size - 1);
        Set<LongPieces> pieces = core.enumerate();
        for (int count = 0; count < 10000; count++) {
            ArrayList<Piece> sample = new ArrayList<>();
            int holdIndex = 0;
            for (int index = 1; index < size; index++) {
                if (randoms.nextBoolean(0.3)) {
                    // そのまま追加
                    sample.add(blocks.get(index));
                } else {
                    // ホールドを追加
                    sample.add(blocks.get(holdIndex));
                    holdIndex = index;
                }
            }
            replacedertThat(new LongPieces(sample)).isIn(pieces);
        }
    }
}

1 Source : BuildUpTest.java
with MIT License
from knewjade

@Test
@LongTest
void cansBuildRandomLongByCheck() {
    Randoms randoms = new Randoms();
    // Create field
    int height = 4;
    // Initialize
    MinoFactory minoFactory = new MinoFactory();
    MinoShifter minoShifter = new MinoShifter();
    MinoRotation minoRotation = MinoRotation.create();
    PerfectValidator validator = new PerfectValidator();
    CheckerUsingHold<Action> checker = new CheckerUsingHold<>(minoFactory, validator);
    Candidate<Action> candidate = new LockedCandidate(minoFactory, minoShifter, minoRotation, height);
    LockedReachable reachable = new LockedReachable(minoFactory, minoShifter, minoRotation, height);
    AtomicInteger counter = new AtomicInteger();
    for (int count = 0; count < 50; count++) {
        // Pickup solution from checker
        int numOfMinos = randoms.nextIntClosed(7, 10);
        Field field = randoms.field(height, numOfMinos);
        List<Piece> pieces = randoms.blocks(numOfMinos);
        boolean check = checker.check(field, pieces, candidate, height, numOfMinos);
        if (check) {
            counter.incrementAndGet();
            Stream<Operation> operationStream = ResultHelper.createOperationStream(checker.getResult());
            Operations operations = new Operations(operationStream);
            List<MinoOperationWithKey> operationWithKeys = OperationTransform.parseToOperationWithKeys(field, operations, minoFactory, height);
            replacedertThat(BuildUp.cansBuild(field, operationWithKeys, height, reachable)).as(FieldView.toString(field) + pieces).isTrue();
        }
    }
}

1 Source : BuildUpTest.java
with MIT License
from knewjade

@Test
void cansBuildRandomShortByCheck() {
    Randoms randoms = new Randoms();
    // Create field
    int height = 4;
    // Initialize
    MinoFactory minoFactory = new MinoFactory();
    MinoShifter minoShifter = new MinoShifter();
    MinoRotation minoRotation = MinoRotation.create();
    PerfectValidator validator = new PerfectValidator();
    CheckerUsingHold<Action> checker = new CheckerUsingHold<>(minoFactory, validator);
    Candidate<Action> candidate = new LockedCandidate(minoFactory, minoShifter, minoRotation, height);
    LockedReachable reachable = new LockedReachable(minoFactory, minoShifter, minoRotation, height);
    AtomicInteger counter = new AtomicInteger();
    for (int count = 0; count < 10000; count++) {
        // Pickup solution from checker
        int numOfMinos = randoms.nextIntOpen(1, 7);
        Field field = randoms.field(height, numOfMinos);
        List<Piece> pieces = randoms.blocks(numOfMinos);
        boolean check = checker.check(field, pieces, candidate, height, numOfMinos);
        if (check) {
            counter.incrementAndGet();
            Stream<Operation> operationStream = ResultHelper.createOperationStream(checker.getResult());
            Operations operations = new Operations(operationStream);
            List<MinoOperationWithKey> operationWithKeys = OperationTransform.parseToOperationWithKeys(field, operations, minoFactory, height);
            replacedertThat(BuildUp.cansBuild(field, operationWithKeys, height, reachable)).as(FieldView.toString(field) + pieces).isTrue();
        }
    }
}