diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 0000000..11bd9d2
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,31 @@
+## 📑 기능 요구 사항
+
+**입력**
+
+- [x] 참석자들의 이름을 입력 받는다
+    - [x] `,` 로 구분한다.
+    - [x] 한글이 아니라면 예외가 발생한다.
+    - [x] 이름은 중복될 수 없다.
+- [x] 최대 짝(그룹) 인원 수를 입력 받는다.
+    - [x] 숫자가 아니라면 예외가 발생한다.
+    - [x] 이름 수 < 최대 짝(그룹) 인원 수인 경우 예외가 발생한다.
+- [x] 재추천 여부를 입력 받는다.
+    - [x] `y` 또는 `n` 가 아니라면 예외가 발생한다.
+
+**출력**
+
+- [x] 짝 추천 결과를 출력한다
+    - [x] `[ 이름1 | ... | 이름2 ]` 형식으로 출력한다.
+- [x] 예외는 `[ERROR]`와 메시지를 함께 출력한다.
+
+**사람**
+
+- [x] 이름은 5글자 이내이다.
+
+**짝**
+
+- [x] 최대 짝 수는 사람 수보다 작거나 같아야 한다.
+
+**매칭**
+
+- [x] 랜덤으로 매칭한다.
\ No newline at end of file
diff --git a/src/main/java/leets/leets_mate/LeetsMateApplication.java b/src/main/java/leets/leets_mate/LeetsMateApplication.java
index e48ce2b..e85d0f6 100644
--- a/src/main/java/leets/leets_mate/LeetsMateApplication.java
+++ b/src/main/java/leets/leets_mate/LeetsMateApplication.java
@@ -1,42 +1,11 @@
 package leets.leets_mate;
 
-import java.util.*;
+import leets.leets_mate.controller.Computer;
 
 public class LeetsMateApplication {
 
-    // 동작 함수입니다.
-    public void run() {
-    }
-
-    // 문자열로된 멤버들을 리스트로 분리하는 함수입니다.
-    public List<String> parseMembers(String members) {
-        return new ArrayList<>();
-    }
-
-    // 총 멤버수를 반환합니다.
-    public int memberNumber(List<String> members) {
-        return 0;
-    }
-
-    // 멤버 문자열에 영어가 있는지 검사합니다. 영어가 있다면 예외 출력
-    public void checkHasNoEnglish(String members) {
-    }
-
-    // 멤버수와 최대 짝수 데이터가 유효한지 검사하는 함수입니다. 유효하지 않다면 예외 출력
-    public void checkDataValidity(int memberCount, int maximumGroupSize) {
-    }
-
-    // 랜덤 짝꿍 추첨하는 함수 입니다.
-    public List<List<String>> generateRandomGroups(List<String> memberList, int maximumGroupSize) {
-        return new ArrayList<>();
-    }
-
-    // 결과를 프린트 하는 함수입니다.
-    public void printResult(List<List<String>> result) {
-    }
-
     public static void main(String[] args) {
-        LeetsMateApplication app = new LeetsMateApplication();
-        app.run();
+        Computer computer = new Computer();
+        computer.run();
     }
 }
\ No newline at end of file
diff --git a/src/main/java/leets/leets_mate/controller/Computer.java b/src/main/java/leets/leets_mate/controller/Computer.java
new file mode 100644
index 0000000..dc0310b
--- /dev/null
+++ b/src/main/java/leets/leets_mate/controller/Computer.java
@@ -0,0 +1,69 @@
+package leets.leets_mate.controller;
+
+import leets.leets_mate.domain.*;
+import leets.leets_mate.view.InputView;
+import leets.leets_mate.view.OutputView;
+
+import java.util.List;
+
+public class Computer {
+
+    private final InputView inputView = new InputView();
+    private final OutputView outputView = new OutputView();
+
+    public void run() {
+        outputView.printStartNotice();
+        Names names = readNames();
+        PairCount pairCount = readPairCount(names.countNames());
+
+        PairMatcher pairMatcher = new PairMatcher(pairCount, new RandomNumbersGenerator());
+        matchPairs(pairMatcher, names);
+        outputView.printEndNotice();
+    }
+
+    private void matchPairs(PairMatcher pairMatcher, Names names) {
+        List<Pair> pairs = pairMatcher.match(names);
+        printPairMatchResult(pairs);
+
+        RetryOpinion retryOpinion = readRetry();
+        if (retryOpinion.isContinue()) {
+            outputView.printBreakLine();
+            matchPairs(pairMatcher, names);
+        }
+    }
+
+    private void printPairMatchResult(List<Pair> pairs) {
+        outputView.printPairMatchResultNotice();
+        pairs.forEach(pair -> outputView.printPairMatchResult(pair.names()));
+        outputView.printPairMatchFinishNotice();
+    }
+
+    private Names readNames() {
+        List<String> rawNames = inputView.readNames();
+        try {
+            List<Name> names = rawNames.stream()
+                    .map(Name::new)
+                    .toList();
+            return new Names(names);
+        } catch (IllegalArgumentException e) {
+            outputView.printError(e.getMessage());
+            return readNames();
+        }
+    }
+
+    private PairCount readPairCount(int namesCount) {
+        int pairCount = inputView.readPairCount();
+        try {
+            new PairCountValidator().validate(pairCount, namesCount);
+            return new PairCount(pairCount);
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return readPairCount(namesCount);
+        }
+    }
+
+    private RetryOpinion readRetry() {
+        String input = inputView.readRetry();
+        return RetryOpinion.match(input);
+    }
+}
diff --git a/src/main/java/leets/leets_mate/domain/Name.java b/src/main/java/leets/leets_mate/domain/Name.java
new file mode 100644
index 0000000..01edd9e
--- /dev/null
+++ b/src/main/java/leets/leets_mate/domain/Name.java
@@ -0,0 +1,39 @@
+package leets.leets_mate.domain;
+
+import java.util.Objects;
+
+public class Name {
+
+    private static final int MAX_LENGTH = 5;
+    private static final String ERROR_FORMAT = "[ERROR] 이름은 %d자 이하여야 합니다.";
+
+    private final String name;
+
+    public Name(String name) {
+        validate(name);
+        this.name = name;
+    }
+
+    private void validate(String name) {
+        if (name.length() > MAX_LENGTH) {
+            throw new IllegalArgumentException(String.format(ERROR_FORMAT, MAX_LENGTH));
+        }
+    }
+
+    public String asString() {
+        return name;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Name name = (Name) o;
+        return Objects.equals(this.name, name.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name);
+    }
+}
diff --git a/src/main/java/leets/leets_mate/domain/Names.java b/src/main/java/leets/leets_mate/domain/Names.java
new file mode 100644
index 0000000..864586d
--- /dev/null
+++ b/src/main/java/leets/leets_mate/domain/Names.java
@@ -0,0 +1,50 @@
+package leets.leets_mate.domain;
+
+import java.util.List;
+import java.util.Objects;
+
+public class Names {
+
+    private static final int MIN_SIZE = 2;
+    private static final String ERROR_FORMAT = "[ERROR] 이름은 %d개 이상이어야 합니다.";
+
+    private final List<Name> names;
+
+    public Names(List<Name> names) {
+        validate(names);
+        this.names = names;
+    }
+
+    private void validate(List<Name> names) {
+        if (names.size() < MIN_SIZE) {
+            throw new IllegalArgumentException(String.format(ERROR_FORMAT, MIN_SIZE));
+        }
+    }
+
+    public int countNames() {
+        return names.size();
+    }
+
+    public List<Name> findByIndexes(List<Integer> indexes) {
+        return indexes.stream()
+                .map(names::get)
+                .toList();
+    }
+
+    public List<Name> findByIndexes(RandomNumbers randomNumbers) {
+        return randomNumbers.findNames(names);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Names names = (Names) o;
+        return Objects.equals(this.names, names.names);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(names);
+    }
+}
diff --git a/src/main/java/leets/leets_mate/domain/Pair.java b/src/main/java/leets/leets_mate/domain/Pair.java
new file mode 100644
index 0000000..87c2cba
--- /dev/null
+++ b/src/main/java/leets/leets_mate/domain/Pair.java
@@ -0,0 +1,32 @@
+package leets.leets_mate.domain;
+
+import java.util.List;
+import java.util.Objects;
+
+public class Pair {
+
+    private final List<Name> names;
+
+    public Pair(List<Name> names) {
+        this.names = names;
+    }
+
+    public List<String> names() {
+        return names.stream()
+                .map(Name::asString)
+                .toList();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Pair pair = (Pair) o;
+        return Objects.equals(names, pair.names);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(names);
+    }
+}
diff --git a/src/main/java/leets/leets_mate/domain/PairCount.java b/src/main/java/leets/leets_mate/domain/PairCount.java
new file mode 100644
index 0000000..2d641e6
--- /dev/null
+++ b/src/main/java/leets/leets_mate/domain/PairCount.java
@@ -0,0 +1,14 @@
+package leets.leets_mate.domain;
+
+public class PairCount {
+
+    private final int value;
+
+    public PairCount(int value) {
+        this.value = value;
+    }
+
+    public int value() {
+        return value;
+    }
+}
diff --git a/src/main/java/leets/leets_mate/domain/PairCountValidator.java b/src/main/java/leets/leets_mate/domain/PairCountValidator.java
new file mode 100644
index 0000000..f20d0b5
--- /dev/null
+++ b/src/main/java/leets/leets_mate/domain/PairCountValidator.java
@@ -0,0 +1,13 @@
+package leets.leets_mate.domain;
+
+public class PairCountValidator {
+
+    private static final int MIN_COUNT = 2;
+    private static final String ERROR_FORMAT = "[ERROR] 최대 짝 수는 %d 이상, 이름 수 이하여야 합니다.";
+
+    public void validate(int maxCount, int namesCount) {
+        if (maxCount < MIN_COUNT || maxCount > namesCount) {
+            throw new IllegalArgumentException(String.format(ERROR_FORMAT, MIN_COUNT));
+        }
+    }
+}
diff --git a/src/main/java/leets/leets_mate/domain/PairMatcher.java b/src/main/java/leets/leets_mate/domain/PairMatcher.java
new file mode 100644
index 0000000..fcdc32a
--- /dev/null
+++ b/src/main/java/leets/leets_mate/domain/PairMatcher.java
@@ -0,0 +1,23 @@
+package leets.leets_mate.domain;
+
+import java.util.List;
+
+public class PairMatcher {
+
+    private final PairCount pairCount;
+    private final RandomNumbersGenerator randomNumbersGenerator;
+
+    public PairMatcher(PairCount pairCount, RandomNumbersGenerator randomNumbersGenerator) {
+        this.pairCount = pairCount;
+        this.randomNumbersGenerator = randomNumbersGenerator;
+    }
+
+    public List<Pair> match(Names names) {
+        RandomNumbers randomNumbers = randomNumbersGenerator.randomNumbers(names.countNames());
+        List<RandomNumbers> splitRandomNumbers = randomNumbers.splitBySize(pairCount.value());
+        return splitRandomNumbers.stream()
+                .map(names::findByIndexes)
+                .map(Pair::new)
+                .toList();
+    }
+}
diff --git a/src/main/java/leets/leets_mate/domain/RandomNumbers.java b/src/main/java/leets/leets_mate/domain/RandomNumbers.java
new file mode 100644
index 0000000..cfa98b4
--- /dev/null
+++ b/src/main/java/leets/leets_mate/domain/RandomNumbers.java
@@ -0,0 +1,27 @@
+package leets.leets_mate.domain;
+
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class RandomNumbers {
+
+    private final List<Integer> values;
+
+    public RandomNumbers(List<Integer> values) {
+        this.values = values;
+    }
+
+    public List<RandomNumbers> splitBySize(int size) {
+        int length = values.size();
+        return IntStream.iterate(0, i -> i < length, i -> i + size)
+                .mapToObj(i -> values.subList(i, Math.min(i + size, length)))
+                .map(RandomNumbers::new)
+                .toList();
+    }
+
+    public List<Name> findNames(List<Name> names) {
+        return values.stream()
+                .map(names::get)
+                .toList();
+    }
+}
diff --git a/src/main/java/leets/leets_mate/domain/RandomNumbersGenerator.java b/src/main/java/leets/leets_mate/domain/RandomNumbersGenerator.java
new file mode 100644
index 0000000..a3096a8
--- /dev/null
+++ b/src/main/java/leets/leets_mate/domain/RandomNumbersGenerator.java
@@ -0,0 +1,17 @@
+package leets.leets_mate.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class RandomNumbersGenerator {
+
+    public RandomNumbers randomNumbers(int bound) {
+        List<Integer> randomNumbers = new ArrayList<>(IntStream.range(0, bound)
+                .boxed()
+                .toList());
+        Collections.shuffle(randomNumbers);
+        return new RandomNumbers(randomNumbers);
+    }
+}
diff --git a/src/main/java/leets/leets_mate/domain/RetryOpinion.java b/src/main/java/leets/leets_mate/domain/RetryOpinion.java
new file mode 100644
index 0000000..e88ad93
--- /dev/null
+++ b/src/main/java/leets/leets_mate/domain/RetryOpinion.java
@@ -0,0 +1,28 @@
+package leets.leets_mate.domain;
+
+import java.util.Arrays;
+
+public enum RetryOpinion {
+
+    CONTINUE("y", true),
+    STOP("n", false);
+
+    private final String input;
+    private final boolean hasRetry;
+
+    RetryOpinion(String input, boolean hasRetry) {
+        this.input = input;
+        this.hasRetry = hasRetry;
+    }
+
+    public static RetryOpinion match(String input) {
+        return Arrays.stream(values())
+                .filter(retryOpinion -> retryOpinion.input.equals(input))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("유효하지 않은 값입니다."));
+    }
+
+    public boolean isContinue() {
+        return this.hasRetry;
+    }
+}
diff --git a/src/main/java/leets/leets_mate/view/InputView.java b/src/main/java/leets/leets_mate/view/InputView.java
new file mode 100644
index 0000000..0e9580d
--- /dev/null
+++ b/src/main/java/leets/leets_mate/view/InputView.java
@@ -0,0 +1,76 @@
+package leets.leets_mate.view;
+
+import java.util.List;
+import java.util.Scanner;
+import java.util.regex.Pattern;
+
+public class InputView {
+
+    public static final String COMMA = ",";
+    public static final Pattern NAME_FORMAT = Pattern.compile("^[ㄱ-ㅎ|가-힣]+$");
+    public static final Pattern RETRY_FORMAT = Pattern.compile("^[y|n]$");
+    public static final String ERROR_FORMAT = "[ERROR] %s";
+
+    private final Scanner scanner = new Scanner(System.in);
+
+    public List<String> readNames() {
+        System.out.println();
+        System.out.println("멤버의 이름을 입력해 주세요. (, 로 구분)");
+
+        String input = scanner.nextLine();
+        List<String> rawNames = List.of(input.split(COMMA, -1));
+        try {
+            rawNames.forEach(this::validateInput);
+            return rawNames;
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return readNames();
+        }
+    }
+
+    private void validateInput(String rawName) {
+        if (!NAME_FORMAT.matcher(rawName).matches()) {
+            throw new IllegalArgumentException(String.format(ERROR_FORMAT, "한글만 입력해 주세요."));
+        }
+    }
+
+    public int readPairCount() {
+        System.out.println();
+        System.out.println("최대 짝 수를 입력해 주세요.");
+
+        String input = scanner.nextLine();
+        try {
+            return parseToInt(input);
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return readPairCount();
+        }
+    }
+
+    private int parseToInt(String input) {
+        try {
+            return Integer.parseInt(input);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException(String.format(ERROR_FORMAT, "숫자를 입력해 주세요."));
+        }
+    }
+
+    public String readRetry() {
+        System.out.print("다시 구성하시겠습니까? (y or n): ");
+
+        String input = scanner.nextLine();
+        try {
+            validate(input);
+            return input;
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return readRetry();
+        }
+    }
+
+    private void validate(String input) {
+        if (!RETRY_FORMAT.matcher(input).matches()) {
+            throw new IllegalArgumentException("잘못된 입력입니다.");
+        }
+    }
+}
diff --git a/src/main/java/leets/leets_mate/view/OutputView.java b/src/main/java/leets/leets_mate/view/OutputView.java
new file mode 100644
index 0000000..87896dc
--- /dev/null
+++ b/src/main/java/leets/leets_mate/view/OutputView.java
@@ -0,0 +1,41 @@
+package leets.leets_mate.view;
+
+import java.util.List;
+import java.util.StringJoiner;
+
+public class OutputView {
+
+    public void printStartNotice() {
+        System.out.println("[Leets 오늘의 짝에게]를 시작합니다.");
+    }
+
+    public void printPairMatchResultNotice() {
+        System.out.println();
+        System.out.println("오늘의 짝 추천 결과입니다.");
+    }
+
+    public void printPairMatchResult(List<String> pairs) {
+        StringJoiner stringJoiner = new StringJoiner(" | ", "[ ", " ]");
+        for (String pair : pairs) {
+            stringJoiner.add(pair);
+        }
+        System.out.println(stringJoiner);
+    }
+
+    public void printPairMatchFinishNotice() {
+        System.out.println();
+        System.out.println("추천을 완료했습니다.");
+    }
+
+    public void printBreakLine() {
+        System.out.println("--------------------------------");
+    }
+
+    public void printEndNotice() {
+        System.out.println("자리를 이동해 서로에게 인사해주세요.");
+    }
+
+    public void printError(String message) {
+        System.out.println(message);
+    }
+}
diff --git a/src/test/java/leets/leets_mate/LeetsMateApplicationTests.java b/src/test/java/leets/leets_mate/LeetsMateApplicationTests.java
index 706e295..d359a28 100644
--- a/src/test/java/leets/leets_mate/LeetsMateApplicationTests.java
+++ b/src/test/java/leets/leets_mate/LeetsMateApplicationTests.java
@@ -1,47 +1,4 @@
 package leets.leets_mate;
 
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import java.util.Arrays;
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
-
 class LeetsMateApplicationTests {
-    LeetsMateApplication app;
-
-    @BeforeEach
-    void setUp() {
-        app = new LeetsMateApplication();
-    }
-
-    @Test
-    void 입력받은_문자열을_파싱하여_리스트로_만든다() {
-        String members = "리츠에,오신,걸,환영합니다";
-        List<String> actual = app.parseMembers(members);
-        assertThat(actual).containsExactly("리츠에", "오신", "걸", "환영합니다");
-    }
-
-    @Test
-    void 멤버수를_반환한다() {
-        List<String> members = Arrays.asList("리츠에", "오신", "걸", "환영합니다");
-        int actual = app.memberNumber(members);
-        assertThat(actual).isEqualTo(4);
-    }
-
-    @Test
-    void 멤버수와_최대_멤버수를_잘못_입력한_경우_예외를_반환한다() {
-        assertThrows(Exception.class, () -> {
-            app.checkDataValidity(3, 4);
-        });
-    }
-
-    @Test
-    void 멤버_문자열에_영어를_입력한_경우_예외를_반환한다() {
-        assertThrows(Exception.class, () -> {
-            app.checkHasNoEnglish("welcome,to,leets");
-        });
-    }
 }
\ No newline at end of file
diff --git a/src/test/java/leets/leets_mate/domain/NameTest.java b/src/test/java/leets/leets_mate/domain/NameTest.java
new file mode 100644
index 0000000..590e1a3
--- /dev/null
+++ b/src/test/java/leets/leets_mate/domain/NameTest.java
@@ -0,0 +1,16 @@
+package leets.leets_mate.domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+
+public class NameTest {
+
+    @Test
+    @DisplayName("이름의 길이가 6글자 이상이라면 예외가 발생한다.")
+    void name_InvalidLength_ExceptionThrown() {
+        assertThatIllegalArgumentException()
+                .isThrownBy(() -> new Name("나아연이라능"));
+    }
+}
diff --git a/src/test/java/leets/leets_mate/domain/NamesTest.java b/src/test/java/leets/leets_mate/domain/NamesTest.java
new file mode 100644
index 0000000..ff424aa
--- /dev/null
+++ b/src/test/java/leets/leets_mate/domain/NamesTest.java
@@ -0,0 +1,32 @@
+package leets.leets_mate.domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class NamesTest {
+
+    private final Names names = new Names(List.of(
+            new Name("아연"),
+            new Name("나아연"),
+            new Name("나나아연"),
+            new Name("나나나아연")
+    ));
+
+    @Test
+    @DisplayName("이름 수를 반환한다.")
+    void countNames() {
+        assertThat(names.countNames()).isEqualTo(4);
+    }
+
+    @Test
+    @DisplayName("해당 위치에 존재하는 이름을 반환한다.")
+    void findByIndexes() {
+        List<Name> namesByIndexes = names.findByIndexes(List.of(1, 3));
+
+        assertThat(namesByIndexes).containsOnly(new Name("나아연"), new Name("나나나아연"));
+    }
+}
diff --git a/src/test/java/leets/leets_mate/domain/PairMatcherTest.java b/src/test/java/leets/leets_mate/domain/PairMatcherTest.java
new file mode 100644
index 0000000..a26b61d
--- /dev/null
+++ b/src/test/java/leets/leets_mate/domain/PairMatcherTest.java
@@ -0,0 +1,64 @@
+package leets.leets_mate.domain;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PairMatcherTest {
+
+    private final Name name1 = new Name("아연");
+    private final Name name2 = new Name("나아연");
+    private final Name name3 = new Name("나나아연");
+    private final Name name4 = new Name("나나나아연");
+    private Names names;
+
+    @BeforeEach
+    void setUp() {
+
+        names = new Names(
+                List.of(name1, name2, name3, name4)
+        );
+    }
+
+    @Test
+    @DisplayName("나머지 없이 랜덤으로 짝을 매치한다.")
+    void pairMatcher_Multiple() {
+        PairMatcher pairMatcher = new PairMatcher(new PairCount(2), new RandomNumbersGenerator() {
+
+            @Override
+            public RandomNumbers randomNumbers(int bound) {
+                return new RandomNumbers(List.of(0, 3, 1, 2));
+            }
+        });
+
+        List<Pair> pairs = pairMatcher.match(names);
+
+        assertThat(pairs).containsOnly(
+                new Pair(List.of(name1, name4)),
+                new Pair(List.of(name2, name3))
+        );
+    }
+
+    @Test
+    @DisplayName("나머지가 있어도 랜덤으로 짝을 매치한다.")
+    void pairMatcher_overNamesCount_ExceptionThrown() {
+        PairMatcher pairMatcher = new PairMatcher(new PairCount(3), new RandomNumbersGenerator() {
+
+            @Override
+            public RandomNumbers randomNumbers(int bound) {
+                return new RandomNumbers(List.of(0, 3, 1, 2));
+            }
+        });
+
+        List<Pair> pairs = pairMatcher.match(names);
+
+        assertThat(pairs).containsOnly(
+                new Pair(List.of(name1, name4, name2)),
+                new Pair(List.of(name3))
+        );
+    }
+}