Egyszerű függvények tesztelése 2.

Hozzon létre egy functions.py fájlt az alábbi tartalommal:

def multiply_by_four(a: int) -> int:
    """Megszorozza 4-gyel a megkapott 'a' egész számot."""
    return a * 4

def cubed(a: float) -> float:
    """Harmadik hatványra emeli a megkapott 'a' tizedestörtet."""
    return a ** 3

def multiply(a: float, b: float) -> float:
    """Összeszorozza az 'a' és 'b' tizedestörteket."""
    return a * b

def str_replace(s: str, r1: str, r2) -> str:
    """Az input 's' stringben kicseréli az 'r1' string-et az 'r2 stringre."""
    s.replace(r1, r2)

def count_substr(s: str, c: str):
    """Megszámolja hányszor szerepel az 's' stringben a 'c' string."""
    count = 0

    for l in s:
        if l == 'c':
            count += 1
    
    return count

def apply_not(l: list[bool]) -> list[bool]:
    """Az input 'l' lista minden elemére alkalmazza a not műveletet."""
    new_list = []

    for e in l:
        new_list.append(not e)

def remove_str(s: str, f: str) -> str:
    """Kitörli az 's' stringben előforduló 'f' stringeket."""
    new_str = ""

    for l in s:
        if l != f:
            new_str += l
    
    return new_str

def filter_list(l: list[int], f: int) -> list[int]:
    """Kiszűri az 'l' listában előforduló 'f' számokat."""
    new_list = []

    for e in l:
        if e == f:
            new_list.append(e)

def compare_list(l: list[int], c: int) -> list[int]:
    """Az input 'l' minden elemére eldönti, hogy kisebb-e, mint a 'c' egész szám."""
    new_list = []

    for e in l:
        if e < c:
            new_list.append(True)
        else:
            new_list.append(False)
    
    return new_list

def project_second(l: list[list[int]]) -> list[int]:
    """A kapott 'l' kétdimenziós listából kiválogatja a második elemeket."""
    new_list = []

    for e in l:
        new_list.append(e[1])
    
    return new_list

def join_rows(l: list[str]) -> str:
    """Összefűzi az 'l' lista elemeit egy-egy sortöréssel."""
    rows = '\n'.join(l)
    return rows

def join_str(l: list[str], d: str) -> str:
    """Összefűzi az 'l' lista elemeit a 'd' elválasztó string-el."""
    new_str = d.join(l)

    return new_str

def pair_elements(l: list[int]) -> list[list[int]]:
    """Az input 'l' lista elemeit párosítja. A párok egymás utáni elemekből állnak."""
    new_list = []
    for i in range(0, len(l), 2):
        x = i
        new_list.append(l[x:x+2])
    
    return new_list

def has_key(d: dict, s: str) -> bool:
    """Visszaadja, hogy szerepel-e az 's' kulcs a 'd' szótárban."""
    return s in d

def add_key_value(d: dict, k: str, v: int) -> dict:
    """A kapott 'd' szótárat ibővíti a 'k' kulcshoz tartozó 'v' értékkel."""
    new_dict = d
    new_dict[k] = v

    return new_dict

def transform_data(l: list[list]) -> list[dict]:
    """Az input 'l' kétdimenziós listából egy szótárakat tartalmazó listát csinál a következő minta szerint:

    [[1, 2, 3], [4, 5, 6]] -> [{'min': 1, 'max': 2, 'avg': 3}, {'min': 4, 'max': 5, 'avg': 6}]"""
    new_list = []
    for a, b, c in l:
        new_list.append({
            'min': a,
            'max': b,
            'avg': c
        })
    
    return new_list

def parse_data(s: str, dr: str, dc: str) -> list[dict]:
    """Az input 's' táblázat formájú stringet beolvassa egy szótárakat tartalmazó listába. A táblázat minden sorában kettő adat szerepel.
    
    'dr' - a sorokat elválasztó karakter
    'dc' - az oszlopokat elválasztó karakter
    
    Példa:

    Horváth;Béla\\n

    Bacsó;András\\n
    
    Vígh;Noémi

    ->
    
    [
        {'vez': 'Horváth', 'ker':'Béla'},
        {'vez': 'Bacsó', 'ker':'András'},
        {'vez': 'Vígh', 'ker':'Noémi'}
    ]
    """
    new_list = []
    rows = s.split(dr)
    for r in rows:
        row = r.split(dc)
        new_list.append({
            'vez': row[0],
            'ker': row[1]
        })
    
    return new_list

Feladatok

1. Írjon minden egyes függvényre egy-egy pozitív tesztet, amely az adott függvény helyes működését vizsgálja.

A tesztelési feladatok elvégzéséhez hozzon létre egy test_functions_pozitiv.py fájlt. A kezdeti tartalma a következő legyen:

import unittest
from functions import *

class TestAddFunction(unittest.TestCase):

    def multiply_by_four(self):
        # pozitív teszteset helye
    ...

2. Írjon minden egyes függényre egy-egy negatív tesztet. A feladatok elvégzését egy test_functions_negativ.py fájlba végezze.