Restoring authorship annotation for <iaz1607@yandex-team.ru>. Commit 2 of 2.

12 files changed, 287 insertions, 287 deletions

diff --git a/library/python/testing/filter/filter.py b/library/python/testing/filter/filter.py
index 2a6e19388c..a1642bd052 100644
--- a/library/python/testing/filter/filter.py
+++ b/library/python/testing/filter/filter.py
@@ -1,57 +1,57 @@
-# coding: utf-8 
-# TODO move devtools/ya/test/filter.py to library/python/testing/filter/filter.py 
-import re 
-import fnmatch 
-import logging 
- 
-logger = logging.getLogger(__name__) 
-TEST_SUBTEST_SEPARATOR = '::' 
- 
-PARSE_TAG_RE = re.compile("([+-]?[\w:]*)") 
- 
- 
-class FilterException(Exception): 
-    mute = True 
- 
- 
-def fix_filter(flt): 
-    if TEST_SUBTEST_SEPARATOR not in flt and "*" not in flt: 
-        # user wants to filter by test module name 
-        flt = flt + TEST_SUBTEST_SEPARATOR + "*" 
-    return flt 
- 
- 
-def escape_for_fnmatch(s): 
-    return s.replace("[", "[").replace("]", "]") 
- 
- 
-def make_py_file_filter(filter_names): 
-    if filter_names is not None: 
-        with_star = [] 
-        wo_star = set() 
-        for flt in filter_names: 
-            flt = flt.split(':')[0] 
-            if '*' in flt: 
-                with_star.append(flt.split('*')[0] + '*') 
-            else: 
-                wo_star.add(flt) 
- 
-    def predicate(filename): 
-        if filter_names is None: 
-            return True 
-        return filename in wo_star or any([fnmatch.fnmatch(escape_for_fnmatch(filename), escape_for_fnmatch(filter_name)) for filter_name in with_star]) 
- 
-    return predicate 
- 
- 
-def make_name_filter(filter_names): 
-    filter_names = map(fix_filter, filter_names) 
-    filter_full_names = set() 
-    for name in filter_names: 
-        if '*' not in name: 
-            filter_full_names.add(name) 
- 
-    def predicate(testname): 
-        return testname in filter_full_names or any([fnmatch.fnmatch(escape_for_fnmatch(testname), escape_for_fnmatch(filter_name)) for filter_name in filter_names]) 
- 
-    return predicate 
+# coding: utf-8
+# TODO move devtools/ya/test/filter.py to library/python/testing/filter/filter.py
+import re
+import fnmatch
+import logging
+
+logger = logging.getLogger(__name__)
+TEST_SUBTEST_SEPARATOR = '::'
+
+PARSE_TAG_RE = re.compile("([+-]?[\w:]*)")
+
+
+class FilterException(Exception):
+    mute = True
+
+
+def fix_filter(flt):
+    if TEST_SUBTEST_SEPARATOR not in flt and "*" not in flt:
+        # user wants to filter by test module name
+        flt = flt + TEST_SUBTEST_SEPARATOR + "*"
+    return flt
+
+
+def escape_for_fnmatch(s):
+    return s.replace("[", "[").replace("]", "]")
+
+
+def make_py_file_filter(filter_names):
+    if filter_names is not None:
+        with_star = []
+        wo_star = set()
+        for flt in filter_names:
+            flt = flt.split(':')[0]
+            if '*' in flt:
+                with_star.append(flt.split('*')[0] + '*')
+            else:
+                wo_star.add(flt)
+
+    def predicate(filename):
+        if filter_names is None:
+            return True
+        return filename in wo_star or any([fnmatch.fnmatch(escape_for_fnmatch(filename), escape_for_fnmatch(filter_name)) for filter_name in with_star])
+
+    return predicate
+
+
+def make_name_filter(filter_names):
+    filter_names = map(fix_filter, filter_names)
+    filter_full_names = set()
+    for name in filter_names:
+        if '*' not in name:
+            filter_full_names.add(name)
+
+    def predicate(testname):
+        return testname in filter_full_names or any([fnmatch.fnmatch(escape_for_fnmatch(testname), escape_for_fnmatch(filter_name)) for filter_name in filter_names])
+
+    return predicate
diff --git a/library/python/testing/filter/ya.make b/library/python/testing/filter/ya.make
index a23d145921..22c485d258 100644
--- a/library/python/testing/filter/ya.make
+++ b/library/python/testing/filter/ya.make
@@ -1,5 +1,5 @@
-PY23_LIBRARY() 
+PY23_LIBRARY()
 OWNER(g:yatest)
-PY_SRCS(filter.py) 
- 
-END() 
+PY_SRCS(filter.py)
+
+END()
diff --git a/library/python/testing/recipe/ports.py b/library/python/testing/recipe/ports.py
index 1344a58ac9..9f7de1e767 100644
--- a/library/python/testing/recipe/ports.py
+++ b/library/python/testing/recipe/ports.py
@@ -1,33 +1,33 @@
-import os 
-import sys 
-import subprocess 
-import time 
- 
-from yatest.common.network import PortManager 
- 
- 
-def __get_port_range(): 
-    port_count = int(sys.argv[1]) 
-    pid_filename = sys.argv[2] 
-    port_manager = PortManager() 
-    start_port = port_manager.get_port_range(None, port_count) 
-    sys.stderr.write(str(start_port) + "\n") 
-    with open(pid_filename, 'w') as afile: 
-        afile.write(str(os.getpid())) 
-    while 1: 
-        time.sleep(1) 
- 
- 
-def get_port_range(port_count=1, pid_filename="recipe_port.pid"): 
-    env = os.environ.copy() 
-    env["Y_PYTHON_ENTRY_POINT"] = "library.python.testing.recipe.ports:__get_port_range" 
-    res = subprocess.Popen([sys.argv[0], str(port_count), pid_filename], env=env, cwd=os.getcwd(), stderr=subprocess.PIPE) 
-    while not os.path.exists(pid_filename): 
-        time.sleep(0.01) 
-    port_start = int(res.stderr.readline()) 
-    return port_start 
- 
- 
-def release_port_range(pid_filename="recipe_port.pid"): 
-    with open(pid_filename, 'r') as afile: 
-        os.kill(int(afile.read()), 9) 
+import os
+import sys
+import subprocess
+import time
+
+from yatest.common.network import PortManager
+
+
+def __get_port_range():
+    port_count = int(sys.argv[1])
+    pid_filename = sys.argv[2]
+    port_manager = PortManager()
+    start_port = port_manager.get_port_range(None, port_count)
+    sys.stderr.write(str(start_port) + "\n")
+    with open(pid_filename, 'w') as afile:
+        afile.write(str(os.getpid()))
+    while 1:
+        time.sleep(1)
+
+
+def get_port_range(port_count=1, pid_filename="recipe_port.pid"):
+    env = os.environ.copy()
+    env["Y_PYTHON_ENTRY_POINT"] = "library.python.testing.recipe.ports:__get_port_range"
+    res = subprocess.Popen([sys.argv[0], str(port_count), pid_filename], env=env, cwd=os.getcwd(), stderr=subprocess.PIPE)
+    while not os.path.exists(pid_filename):
+        time.sleep(0.01)
+    port_start = int(res.stderr.readline())
+    return port_start
+
+
+def release_port_range(pid_filename="recipe_port.pid"):
+    with open(pid_filename, 'r') as afile:
+        os.kill(int(afile.read()), 9)
diff --git a/library/python/testing/recipe/ya.make b/library/python/testing/recipe/ya.make
index 4698546e42..dd323aa245 100644
--- a/library/python/testing/recipe/ya.make
+++ b/library/python/testing/recipe/ya.make
@@ -5,14 +5,14 @@ OWNER(
 
 PY23_LIBRARY()
 
-PY_SRCS( 
-    __init__.py 
-    ports.py 
-) 
+PY_SRCS(
+    __init__.py
+    ports.py
+)
 
 PEERDIR(
     contrib/python/ipdb
-    library/python/testing/yatest_common 
+    library/python/testing/yatest_common
     library/python/testing/yatest_lib
 )
 
diff --git a/library/python/testing/ya.make b/library/python/testing/ya.make
index 002b406a61..883bc8d7ab 100644
--- a/library/python/testing/ya.make
+++ b/library/python/testing/ya.make
@@ -4,7 +4,7 @@ RECURSE(
     behave
     deprecated
     fake_ya_package
-    filter 
+    filter
     gtest
     gtest/test
     gtest/test/gtest
diff --git a/library/python/testing/yatest_common/yatest/common/path.py b/library/python/testing/yatest_common/yatest/common/path.py
index 313c67ef39..6fed7dda8a 100644
--- a/library/python/testing/yatest_common/yatest/common/path.py
+++ b/library/python/testing/yatest_common/yatest/common/path.py
@@ -59,7 +59,7 @@ def copytree(src, dst, symlinks=False, ignore=None, postprocessing=None):
 def get_unique_file_path(dir_path, file_pattern, create_file=True, max_suffix=10000):
     def atomic_file_create(path):
         try:
-            fd = os.open(path, os.O_CREAT | os.O_EXCL, 0o644) 
+            fd = os.open(path, os.O_CREAT | os.O_EXCL, 0o644)
             os.close(fd)
             return True
         except OSError as e:
diff --git a/library/python/testing/yatest_common/yatest/common/process.py b/library/python/testing/yatest_common/yatest/common/process.py
index 58e12d8f69..a8bcc21f51 100644
--- a/library/python/testing/yatest_common/yatest/common/process.py
+++ b/library/python/testing/yatest_common/yatest/common/process.py
@@ -79,12 +79,12 @@ class InvalidExecutionStateError(Exception):
     pass
 
 
-class SignalInterruptionError(Exception): 
-    def __init__(self, message=None): 
-        super(SignalInterruptionError, self).__init__(message) 
-        self.res = None 
- 
- 
+class SignalInterruptionError(Exception):
+    def __init__(self, message=None):
+        super(SignalInterruptionError, self).__init__(message)
+        self.res = None
+
+
 class InvalidCommandError(Exception):
     pass
 
@@ -284,7 +284,7 @@ class _Execution(object):
     def wait(self, check_exit_code=True, timeout=None, on_timeout=None):
         def _wait():
             finished = None
-            interrupted = False 
+            interrupted = False
             try:
                 if hasattr(os, "wait4"):
                     try:
@@ -321,12 +321,12 @@ class _Execution(object):
                             yatest_logger.debug("Process resource usage is not available as process finished before wait4 was called")
                         else:
                             raise
-            except SignalInterruptionError: 
-                interrupted = True 
-                raise 
+            except SignalInterruptionError:
+                interrupted = True
+                raise
             finally:
-                if not interrupted: 
-                    self._process.wait()  # this has to be here unconditionally, so that all process properties are set 
+                if not interrupted:
+                    self._process.wait()  # this has to be here unconditionally, so that all process properties are set
 
             if not finished:
                 finished = time.time()
diff --git a/library/python/testing/yatest_common/yatest/common/runtime.py b/library/python/testing/yatest_common/yatest/common/runtime.py
index 80f8f70db4..e55e193446 100644
--- a/library/python/testing/yatest_common/yatest/common/runtime.py
+++ b/library/python/testing/yatest_common/yatest/common/runtime.py
@@ -242,11 +242,11 @@ def c_compiler_path():
     return os.environ.get("YA_CC")
 
 
-def get_yt_hdd_path(path=None): 
-    if 'HDD_PATH' in os.environ: 
-        return _join_path(os.environ['HDD_PATH'], path) 
- 
- 
+def get_yt_hdd_path(path=None):
+    if 'HDD_PATH' in os.environ:
+        return _join_path(os.environ['HDD_PATH'], path)
+
+
 def cxx_compiler_path():
     """
     Get path to the gdb
diff --git a/library/python/testing/yatest_lib/test_splitter.py b/library/python/testing/yatest_lib/test_splitter.py
index 2f2ec39a6e..acbcd4300e 100644
--- a/library/python/testing/yatest_lib/test_splitter.py
+++ b/library/python/testing/yatest_lib/test_splitter.py
@@ -18,66 +18,66 @@ def flatten_tests(test_classes):
     return tests
 
 
-def get_sequential_chunk(tests, modulo, modulo_index, is_sorted=False): 
+def get_sequential_chunk(tests, modulo, modulo_index, is_sorted=False):
     """
-    >>> get_sequential_chunk(range(10), 4, 0) 
+    >>> get_sequential_chunk(range(10), 4, 0)
     [0, 1, 2]
-    >>> get_sequential_chunk(range(10), 4, 1) 
+    >>> get_sequential_chunk(range(10), 4, 1)
     [3, 4, 5]
-    >>> get_sequential_chunk(range(10), 4, 2) 
-    [6, 7] 
-    >>> get_sequential_chunk(range(10), 4, 3) 
-    [8, 9] 
-    >>> get_sequential_chunk(range(10), 4, 4) 
+    >>> get_sequential_chunk(range(10), 4, 2)
+    [6, 7]
+    >>> get_sequential_chunk(range(10), 4, 3)
+    [8, 9]
+    >>> get_sequential_chunk(range(10), 4, 4)
     []
-    >>> get_sequential_chunk(range(10), 4, 5) 
+    >>> get_sequential_chunk(range(10), 4, 5)
     []
     """
-    if not is_sorted: 
-        tests = sorted(tests) 
-    chunk_size = len(tests) // modulo 
-    not_used = len(tests) % modulo 
-    shift = chunk_size + (modulo_index < not_used) 
-    start = chunk_size * modulo_index + min(modulo_index, not_used) 
+    if not is_sorted:
+        tests = sorted(tests)
+    chunk_size = len(tests) // modulo
+    not_used = len(tests) % modulo
+    shift = chunk_size + (modulo_index < not_used)
+    start = chunk_size * modulo_index + min(modulo_index, not_used)
     end = start + shift
-    return [] if end > len(tests) else tests[start:end] 
+    return [] if end > len(tests) else tests[start:end]
 
 
-def get_shuffled_chunk(tests, modulo, modulo_index, is_sorted=False): 
+def get_shuffled_chunk(tests, modulo, modulo_index, is_sorted=False):
+    """
+    >>> get_shuffled_chunk(range(10), 4, 0)
+    [0, 4, 8]
+    >>> get_shuffled_chunk(range(10), 4, 1)
+    [1, 5, 9]
+    >>> get_shuffled_chunk(range(10), 4, 2)
+    [2, 6]
+    >>> get_shuffled_chunk(range(10), 4, 3)
+    [3, 7]
+    >>> get_shuffled_chunk(range(10), 4, 4)
+    []
+    >>> get_shuffled_chunk(range(10), 4, 5)
+    []
+    """
+    if not is_sorted:
+        tests = sorted(tests)
+    result_tests = []
+    for i, test in enumerate(tests):
+        if i % modulo == modulo_index:
+            result_tests.append(test)
+    return result_tests
+
+
+def get_splitted_tests(test_entities, modulo, modulo_index, partition_mode, is_sorted=False):
+    if partition_mode == 'SEQUENTIAL':
+        return get_sequential_chunk(test_entities, modulo, modulo_index, is_sorted)
+    elif partition_mode == 'MODULO':
+        return get_shuffled_chunk(test_entities, modulo, modulo_index, is_sorted)
+    else:
+        raise ValueError("detected unknown partition mode: {}".format(partition_mode))
+
+
+def filter_tests_by_modulo(test_classes, modulo, modulo_index, split_by_tests, partition_mode="SEQUENTIAL"):
     """
-    >>> get_shuffled_chunk(range(10), 4, 0) 
-    [0, 4, 8] 
-    >>> get_shuffled_chunk(range(10), 4, 1) 
-    [1, 5, 9] 
-    >>> get_shuffled_chunk(range(10), 4, 2) 
-    [2, 6] 
-    >>> get_shuffled_chunk(range(10), 4, 3) 
-    [3, 7] 
-    >>> get_shuffled_chunk(range(10), 4, 4) 
-    [] 
-    >>> get_shuffled_chunk(range(10), 4, 5) 
-    [] 
-    """ 
-    if not is_sorted: 
-        tests = sorted(tests) 
-    result_tests = [] 
-    for i, test in enumerate(tests): 
-        if i % modulo == modulo_index: 
-            result_tests.append(test) 
-    return result_tests 
- 
- 
-def get_splitted_tests(test_entities, modulo, modulo_index, partition_mode, is_sorted=False): 
-    if partition_mode == 'SEQUENTIAL': 
-        return get_sequential_chunk(test_entities, modulo, modulo_index, is_sorted) 
-    elif partition_mode == 'MODULO': 
-        return get_shuffled_chunk(test_entities, modulo, modulo_index, is_sorted) 
-    else: 
-        raise ValueError("detected unknown partition mode: {}".format(partition_mode)) 
- 
- 
-def filter_tests_by_modulo(test_classes, modulo, modulo_index, split_by_tests, partition_mode="SEQUENTIAL"): 
-    """ 
     >>> test_classes = {x: [x] for x in range(20)}
     >>> filter_tests_by_modulo(test_classes, 4, 0, False)
     {0: [0], 1: [1], 2: [2], 3: [3], 4: [4]}
@@ -92,11 +92,11 @@ def filter_tests_by_modulo(test_classes, modulo, modulo_index, split_by_tests, p
     {8: [8], 9: [9], 5: [5], 6: [6], 7: [7]}
     """
     if split_by_tests:
-        tests = get_splitted_tests(flatten_tests(test_classes), modulo, modulo_index, partition_mode) 
+        tests = get_splitted_tests(flatten_tests(test_classes), modulo, modulo_index, partition_mode)
         test_classes = collections.defaultdict(list)
         for class_name, test_name in tests:
             test_classes[class_name].append(test_name)
         return test_classes
     else:
-        target_classes = get_splitted_tests(test_classes, modulo, modulo_index, partition_mode) 
+        target_classes = get_splitted_tests(test_classes, modulo, modulo_index, partition_mode)
         return {class_name: test_classes[class_name] for class_name in target_classes}
diff --git a/library/python/testing/yatest_lib/tests/test_testsplitter.py b/library/python/testing/yatest_lib/tests/test_testsplitter.py
index 87842e0ceb..394bfe5a74 100644
--- a/library/python/testing/yatest_lib/tests/test_testsplitter.py
+++ b/library/python/testing/yatest_lib/tests/test_testsplitter.py
@@ -1,103 +1,103 @@
-# coding: utf-8 
-from yatest_lib import test_splitter 
- 
- 
-def get_chunks(tests, modulo, mode): 
-    chunks = [] 
-    if mode == "MODULO": 
-        for modulo_index in range(modulo): 
-            chunks.append(test_splitter.get_shuffled_chunk(tests, modulo, modulo_index)) 
-    elif mode == "SEQUENTIAL": 
-        for modulo_index in range(modulo): 
-            chunks.append(test_splitter.get_sequential_chunk(tests, modulo, modulo_index)) 
-    else: 
-        raise ValueError("no such mode") 
-    return chunks 
- 
- 
-def check_not_intersect(chunk_list): 
-    test_set = set() 
-    total_size = 0 
-    for tests in chunk_list: 
-        total_size += len(tests) 
-        test_set.update(tests) 
-    return total_size == len(test_set) 
- 
- 
-def check_max_diff(chunk_list): 
-    return max(map(len, chunk_list)) - min(map(len, chunk_list)) 
- 
- 
-def test_lot_of_chunks(): 
-    for chunk_count in range(10, 20): 
-        for tests_count in range(chunk_count): 
-            chunks = get_chunks(range(tests_count), chunk_count, "SEQUENTIAL") 
-            assert check_not_intersect(chunks) 
-            assert check_max_diff(chunks) <= 1 
-            assert chunks.count([]) == chunk_count - tests_count 
-            assert len(chunks) == chunk_count 
-            chunks = get_chunks(range(tests_count), chunk_count, "MODULO") 
-            assert check_not_intersect(chunks) 
-            assert check_max_diff(chunks) <= 1 
-            assert chunks.count([]) == chunk_count - tests_count 
-            assert len(chunks) == chunk_count 
- 
- 
-def test_lot_of_tests(): 
-    for tests_count in range(10, 20): 
-        for chunk_count in range(2, tests_count): 
-            chunks = get_chunks(range(tests_count), chunk_count, "SEQUENTIAL") 
-            assert check_not_intersect(chunks) 
-            assert check_max_diff(chunks) <= 1 
-            assert len(chunks) == chunk_count 
-            chunks = get_chunks(range(tests_count), chunk_count, "MODULO") 
-            assert check_not_intersect(chunks) 
-            assert check_max_diff(chunks) <= 1 
-            assert len(chunks) == chunk_count 
- 
- 
-def prime_chunk_count(): 
-    for chunk_count in [7, 11, 13, 17, 23, 29]: 
-        for tests_count in range(chunk_count): 
-            chunks = get_chunks(range(tests_count), chunk_count, "SEQUENTIAL") 
-            assert check_not_intersect(chunks) 
-            assert check_max_diff(chunks) <= 1 
-            assert len(chunks) == chunk_count 
-            chunks = get_chunks(range(tests_count), chunk_count, "MODULO") 
-            assert check_not_intersect(chunks) 
-            assert check_max_diff(chunks) <= 1 
-            assert len(chunks) == chunk_count 
- 
- 
-def get_divisors(number): 
-    divisors = [] 
-    for d in range(1, number + 1): 
-        if number % d == 0: 
-            divisors.append(d) 
-    return divisors 
- 
- 
-def equal_chunks(): 
-    for chunk_count in range(12, 31): 
-        for tests_count in get_divisors(chunk_count): 
-            chunks = get_chunks(range(tests_count), chunk_count, "SEQUENTIAL") 
-            assert check_not_intersect(chunks) 
-            assert check_max_diff(chunks) == 0 
-            assert len(chunks) == chunk_count 
-            chunks = get_chunks(range(tests_count), chunk_count, "MODULO") 
-            assert check_not_intersect(chunks) 
-            assert check_max_diff(chunks) == 0 
-            assert len(chunks) == chunk_count 
- 
- 
-def chunk_count_equal_tests_count(): 
-    for chunk_count in range(10, 20): 
-        tests_count = chunk_count 
-        chunks = get_chunks(range(tests_count), chunk_count, "SEQUENTIAL") 
-        assert check_not_intersect(chunks) 
-        assert check_max_diff(chunks) <= 1 
-        assert len(chunks) == chunk_count 
-        chunks = get_chunks(range(tests_count), chunk_count, "MODULO") 
-        assert check_not_intersect(chunks) 
-        assert check_max_diff(chunks) <= 1 
-        assert len(chunks) == chunk_count 
+# coding: utf-8
+from yatest_lib import test_splitter
+
+
+def get_chunks(tests, modulo, mode):
+    chunks = []
+    if mode == "MODULO":
+        for modulo_index in range(modulo):
+            chunks.append(test_splitter.get_shuffled_chunk(tests, modulo, modulo_index))
+    elif mode == "SEQUENTIAL":
+        for modulo_index in range(modulo):
+            chunks.append(test_splitter.get_sequential_chunk(tests, modulo, modulo_index))
+    else:
+        raise ValueError("no such mode")
+    return chunks
+
+
+def check_not_intersect(chunk_list):
+    test_set = set()
+    total_size = 0
+    for tests in chunk_list:
+        total_size += len(tests)
+        test_set.update(tests)
+    return total_size == len(test_set)
+
+
+def check_max_diff(chunk_list):
+    return max(map(len, chunk_list)) - min(map(len, chunk_list))
+
+
+def test_lot_of_chunks():
+    for chunk_count in range(10, 20):
+        for tests_count in range(chunk_count):
+            chunks = get_chunks(range(tests_count), chunk_count, "SEQUENTIAL")
+            assert check_not_intersect(chunks)
+            assert check_max_diff(chunks) <= 1
+            assert chunks.count([]) == chunk_count - tests_count
+            assert len(chunks) == chunk_count
+            chunks = get_chunks(range(tests_count), chunk_count, "MODULO")
+            assert check_not_intersect(chunks)
+            assert check_max_diff(chunks) <= 1
+            assert chunks.count([]) == chunk_count - tests_count
+            assert len(chunks) == chunk_count
+
+
+def test_lot_of_tests():
+    for tests_count in range(10, 20):
+        for chunk_count in range(2, tests_count):
+            chunks = get_chunks(range(tests_count), chunk_count, "SEQUENTIAL")
+            assert check_not_intersect(chunks)
+            assert check_max_diff(chunks) <= 1
+            assert len(chunks) == chunk_count
+            chunks = get_chunks(range(tests_count), chunk_count, "MODULO")
+            assert check_not_intersect(chunks)
+            assert check_max_diff(chunks) <= 1
+            assert len(chunks) == chunk_count
+
+
+def prime_chunk_count():
+    for chunk_count in [7, 11, 13, 17, 23, 29]:
+        for tests_count in range(chunk_count):
+            chunks = get_chunks(range(tests_count), chunk_count, "SEQUENTIAL")
+            assert check_not_intersect(chunks)
+            assert check_max_diff(chunks) <= 1
+            assert len(chunks) == chunk_count
+            chunks = get_chunks(range(tests_count), chunk_count, "MODULO")
+            assert check_not_intersect(chunks)
+            assert check_max_diff(chunks) <= 1
+            assert len(chunks) == chunk_count
+
+
+def get_divisors(number):
+    divisors = []
+    for d in range(1, number + 1):
+        if number % d == 0:
+            divisors.append(d)
+    return divisors
+
+
+def equal_chunks():
+    for chunk_count in range(12, 31):
+        for tests_count in get_divisors(chunk_count):
+            chunks = get_chunks(range(tests_count), chunk_count, "SEQUENTIAL")
+            assert check_not_intersect(chunks)
+            assert check_max_diff(chunks) == 0
+            assert len(chunks) == chunk_count
+            chunks = get_chunks(range(tests_count), chunk_count, "MODULO")
+            assert check_not_intersect(chunks)
+            assert check_max_diff(chunks) == 0
+            assert len(chunks) == chunk_count
+
+
+def chunk_count_equal_tests_count():
+    for chunk_count in range(10, 20):
+        tests_count = chunk_count
+        chunks = get_chunks(range(tests_count), chunk_count, "SEQUENTIAL")
+        assert check_not_intersect(chunks)
+        assert check_max_diff(chunks) <= 1
+        assert len(chunks) == chunk_count
+        chunks = get_chunks(range(tests_count), chunk_count, "MODULO")
+        assert check_not_intersect(chunks)
+        assert check_max_diff(chunks) <= 1
+        assert len(chunks) == chunk_count
diff --git a/library/python/testing/yatest_lib/tests/ya.make b/library/python/testing/yatest_lib/tests/ya.make
index 6670106533..8586c6ef7d 100644
--- a/library/python/testing/yatest_lib/tests/ya.make
+++ b/library/python/testing/yatest_lib/tests/ya.make
@@ -1,14 +1,14 @@
 OWNER(g:yatest)
- 
+
 PY23_TEST()
- 
-PEERDIR( 
-    library/python/testing/yatest_lib 
-) 
- 
-TEST_SRCS( 
+
+PEERDIR(
+    library/python/testing/yatest_lib
+)
+
+TEST_SRCS(
     test_external.py
-    test_testsplitter.py 
-) 
- 
-END() 
+    test_testsplitter.py
+)
+
+END()
diff --git a/library/python/testing/yatest_lib/ya.make b/library/python/testing/yatest_lib/ya.make
index 9b1d5224ea..342bae82ba 100644
--- a/library/python/testing/yatest_lib/ya.make
+++ b/library/python/testing/yatest_lib/ya.make
@@ -6,7 +6,7 @@ PY_SRCS(
     NAMESPACE
     yatest_lib
     external.py
-    test_splitter.py 
+    test_splitter.py
     tools.py
     ya.py
 )
@@ -22,5 +22,5 @@ IF(PYTHON2)
 ENDIF()
 
 END()
- 
-RECURSE_FOR_TESTS(tests) 
+
+RECURSE_FOR_TESTS(tests)