{"task_id": "DREval/0", "entry_point": "has_close_elements", "code": "from typing import List\n\n\ndef has_close_elements(numbers: List[float], threshold: float) -> bool:\n \"\"\" Check if in given list of numbers, are any two numbers closer to each other than\n given threshold.\n >>> has_close_elements([1.0, 2.0, 3.0], 0.5)\n False\n >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)\n True\n \"\"\"\n for idx, elem in enumerate(numbers):\n for idx2, elem2 in enumerate(numbers):\n if idx != idx2:\n distance = abs(elem - elem2)\n if distance < threshold:\n return True\n\n return False\n", "inputs": ["([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.3,)", "([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.05,)", "([1.0, 2.0, 5.9, 4.0, 5.0], 0.95,)", "([1.0, 2.0, 5.9, 4.0, 5.0], 0.8,)", "([1.0, 2.0, 3.0, 4.0, 5.0, 2.0], 0.1,)", "([1.1, 2.2, 3.1, 4.1, 5.1], 1.0,)", "([1.1, 2.2, 3.1, 4.1, 5.1], 0.5,)"], "outputs": ["True", "False", "True", "False", "True", "True", "False"], "test": null} {"task_id": "DREval/1", "entry_point": "separate_paren_groups", "code": "from typing import List\n\n\ndef separate_paren_groups(paren_string: str) -> List[str]:\n \"\"\" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to\n separate those group into separate strings and return the list of those.\n Separate groups are balanced (each open brace is properly closed) and not nested within each other\n Ignore any spaces in the input string.\n >>> separate_paren_groups('( ) (( )) (( )( ))')\n ['()', '(())', '(()())']\n \"\"\"\n result = []\n current_string = []\n current_depth = 0\n\n for c in paren_string:\n if c == '(':\n current_depth += 1\n current_string.append(c)\n elif c == ')':\n current_depth -= 1\n current_string.append(c)\n\n if current_depth == 0:\n result.append(''.join(current_string))\n current_string.clear()\n\n return result\n", "inputs": ["('(()()) ((())) () ((())()())',)", "('() (()) ((())) (((())))',)", "('(()(())((())))',)", "('( ) (( )) (( )( ))',)"], "outputs": ["['(()())', '((()))', '()', '((())()())']", "['()', '(())', '((()))', '(((())))']", "['(()(())((())))']", "['()', '(())', '(()())']"], "test": null} {"task_id": "DREval/2", "entry_point": "below_zero", "code": "from typing import List\n\n\ndef below_zero(operations: List[int]) -> bool:\n \"\"\" You're given a list of deposit and withdrawal operations on a bank account that starts with\n zero balance. Your task is to detect if at any point the balance of account fallls below zero, and\n at that point function should return True. Otherwise it should return False.\n >>> below_zero([1, 2, 3])\n False\n >>> below_zero([1, 2, -4, 5])\n True\n \"\"\"\n balance = 0\n\n for op in operations:\n balance += op\n if balance < 0:\n return True\n\n return False\n", "inputs": ["([],)", "([1, 2, -3, 1, 2, -3],)", "([1, 2, -4, 5, 6],)", "([1, -1, 2, -2, 5, -5, 4, -4],)", "([1, -1, 2, -2, 5, -5, 4, -5],)", "([1, -2, 2, -2, 5, -5, 4, -4],)"], "outputs": ["False", "False", "True", "False", "True", "True"], "test": null} {"task_id": "DREval/3", "entry_point": "intersperse", "code": "from typing import List\n\n\ndef intersperse(numbers: List[int], delimeter: int) -> List[int]:\n \"\"\" Insert a number 'delimeter' between every two consecutive elements of input list `numbers'\n >>> intersperse([], 4)\n []\n >>> intersperse([1, 2, 3], 4)\n [1, 4, 2, 4, 3]\n \"\"\"\n if not numbers:\n return []\n\n result = []\n\n for n in numbers[:-1]:\n result.append(n)\n result.append(delimeter)\n\n result.append(numbers[-1])\n\n return result\n", "inputs": ["([], 7,)", "([5, 6, 3, 2], 8,)", "([2, 2, 2], 2,)"], "outputs": ["[]", "[5, 8, 6, 8, 3, 8, 2]", "[2, 2, 2, 2, 2]"], "test": null} {"task_id": "DREval/4", "entry_point": "parse_nested_parens", "code": "from typing import List\n\n\ndef parse_nested_parens(paren_string: str) -> List[int]:\n \"\"\" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.\n For each of the group, output the deepest level of nesting of parentheses.\n E.g. (()()) has maximum two levels of nesting while ((())) has three.\n\n >>> parse_nested_parens('(()()) ((())) () ((())()())')\n [2, 3, 1, 3]\n \"\"\"\n def parse_paren_group(s):\n depth = 0\n max_depth = 0\n for c in s:\n if c == '(':\n depth += 1\n max_depth = max(depth, max_depth)\n else:\n depth -= 1\n\n return max_depth\n\n return [parse_paren_group(x) for x in paren_string.split(' ') if x]\n", "inputs": ["('(()()) ((())) () ((())()())',)", "('() (()) ((())) (((())))',)", "('(()(())((())))',)"], "outputs": ["[2, 3, 1, 3]", "[1, 2, 3, 4]", "[4]"], "test": null} {"task_id": "DREval/5", "entry_point": "sum_product", "code": "from typing import List, Tuple\n\n\ndef sum_product(numbers: List[int]) -> Tuple[int, int]:\n \"\"\" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.\n Empty sum should be equal to 0 and empty product should be equal to 1.\n >>> sum_product([])\n (0, 1)\n >>> sum_product([1, 2, 3, 4])\n (10, 24)\n \"\"\"\n sum_value = 0\n prod_value = 1\n\n for n in numbers:\n sum_value += n\n prod_value *= n\n return sum_value, prod_value\n", "inputs": ["([],)", "([1, 1, 1],)", "([100, 0],)", "([3, 5, 7],)", "([10],)"], "outputs": ["(0, 1)", "(3, 1)", "(100, 0)", "(3 + 5 + 7, 3 * 5 * 7)", "(10, 10)"], "test": null} {"task_id": "DREval/6", "entry_point": "rolling_max", "code": "from typing import List, Tuple\n\n\ndef rolling_max(numbers: List[int]) -> List[int]:\n \"\"\" From a given list of integers, generate a list of rolling maximum element found until given moment\n in the sequence.\n >>> rolling_max([1, 2, 3, 2, 3, 4, 2])\n [1, 2, 3, 3, 3, 4, 4]\n \"\"\"\n running_max = None\n result = []\n\n for n in numbers:\n if running_max is None:\n running_max = n\n else:\n running_max = max(running_max, n)\n\n result.append(running_max)\n\n return result\n", "inputs": ["([],)", "([1, 2, 3, 4],)", "([4, 3, 2, 1],)", "([3, 2, 3, 100, 3],)"], "outputs": ["[]", "[1, 2, 3, 4]", "[4, 4, 4, 4]", "[3, 3, 3, 100, 100]"], "test": null} {"task_id": "DREval/7", "entry_point": "make_palindrome", "code": "\n\ndef is_palindrome(string: str) -> bool:\n \"\"\" Test if given string is a palindrome \"\"\"\n return string == string[::-1]\n\n\ndef make_palindrome(string: str) -> str:\n \"\"\" Find the shortest palindrome that begins with a supplied string.\n Algorithm idea is simple:\n - Find the longest postfix of supplied string that is a palindrome.\n - Append to the end of the string reverse of a string prefix that comes before the palindromic suffix.\n >>> make_palindrome('')\n ''\n >>> make_palindrome('cat')\n 'catac'\n >>> make_palindrome('cata')\n 'catac'\n \"\"\"\n if not string:\n return ''\n\n beginning_of_suffix = 0\n\n while not is_palindrome(string[beginning_of_suffix:]):\n beginning_of_suffix += 1\n\n return string + string[:beginning_of_suffix][::-1]\n", "inputs": ["('',)", "('x',)", "('xyz',)", "('xyx',)", "('jerry',)"], "outputs": ["''", "'x'", "'xyzyx'", "'xyx'", "'jerryrrej'"], "test": null} {"task_id": "DREval/8", "entry_point": "longest", "code": "from typing import List, Optional\n\n\ndef longest(strings: List[str]) -> Optional[str]:\n \"\"\" Out of list of strings, return the longest one. Return the first one in case of multiple\n strings of the same length. Return None in case the input list is empty.\n >>> longest([])\n\n >>> longest(['a', 'b', 'c'])\n 'a'\n >>> longest(['a', 'bb', 'ccc'])\n 'ccc'\n \"\"\"\n if not strings:\n return None\n\n maxlen = max(len(x) for x in strings)\n for s in strings:\n if len(s) == maxlen:\n return s\n", "inputs": ["([],)", "(['x', 'y', 'z'],)", "(['x', 'yyy', 'zzzz', 'www', 'kkkk', 'abc'],)"], "outputs": ["None", "'x'", "'zzzz'"], "test": null} {"task_id": "DREval/9", "entry_point": "all_prefixes", "code": "from typing import List\n\n\ndef all_prefixes(string: str) -> List[str]:\n \"\"\" Return list of all prefixes from shortest to longest of the input string\n >>> all_prefixes('abc')\n ['a', 'ab', 'abc']\n \"\"\"\n result = []\n\n for i in range(len(string)):\n result.append(string[:i+1])\n return result\n", "inputs": ["('',)", "('asdfgh',)", "('WWW',)"], "outputs": ["[]", "['a', 'as', 'asd', 'asdf', 'asdfg', 'asdfgh']", "['W', 'WW', 'WWW']"], "test": null} {"task_id": "DREval/10", "entry_point": "how_many_times", "code": "\n\ndef how_many_times(string: str, substring: str) -> int:\n \"\"\" Find how many times a given substring can be found in the original string. Count overlaping cases.\n >>> how_many_times('', 'a')\n 0\n >>> how_many_times('aaa', 'a')\n 3\n >>> how_many_times('aaaa', 'aa')\n 3\n \"\"\"\n times = 0\n\n for i in range(len(string) - len(substring) + 1):\n if string[i:i+len(substring)] == substring:\n times += 1\n\n return times\n", "inputs": ["('', 'x',)", "('xyxyxyx', 'x',)", "('cacacacac', 'cac',)", "('john doe', 'john',)"], "outputs": ["0", "4", "4", "1"], "test": null} {"task_id": "DREval/11", "entry_point": "find_closest_elements", "code": "from typing import List, Tuple\n\n\ndef find_closest_elements(numbers: List[float]) -> Tuple[float, float]:\n \"\"\" From a supplied list of numbers (of length at least two) select and return two that are the closest to each\n other and return them in order (smaller number, larger number).\n >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])\n (2.0, 2.2)\n >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])\n (2.0, 2.0)\n \"\"\"\n closest_pair = None\n distance = None\n\n for idx, elem in enumerate(numbers):\n for idx2, elem2 in enumerate(numbers):\n if idx != idx2:\n if distance is None:\n distance = abs(elem - elem2)\n closest_pair = tuple(sorted([elem, elem2]))\n else:\n new_distance = abs(elem - elem2)\n if new_distance < distance:\n distance = new_distance\n closest_pair = tuple(sorted([elem, elem2]))\n\n return closest_pair\n", "inputs": ["([1.0, 2.0, 3.9, 4.0, 5.0, 2.2],)", "([1.0, 2.0, 5.9, 4.0, 5.0],)", "([1.0, 2.0, 3.0, 4.0, 5.0, 2.2],)", "([1.0, 2.0, 3.0, 4.0, 5.0, 2.0],)", "([1.1, 2.2, 3.1, 4.1, 5.1],)"], "outputs": ["(3.9, 4.0)", "(5.0, 5.9)", "(2.0, 2.2)", "(2.0, 2.0)", "(2.2, 3.1)"], "test": null} {"task_id": "DREval/12", "entry_point": "factorize", "code": "from typing import List\n\n\ndef factorize(n: int) -> List[int]:\n \"\"\" Return list of prime factors of given integer in the order from smallest to largest.\n Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.\n Input number should be equal to the product of all factors\n >>> factorize(8)\n [2, 2, 2]\n >>> factorize(25)\n [5, 5]\n >>> factorize(70)\n [2, 5, 7]\n \"\"\"\n import math\n fact = []\n i = 2\n while i <= int(math.sqrt(n) + 1):\n if n % i == 0:\n fact.append(i)\n n //= i\n else:\n i += 1\n\n if n > 1:\n fact.append(n)\n return fact\n", "inputs": ["(2,)", "(4,)", "(8,)", "(3 * 19,)", "(3 * 19 * 3 * 19,)", "(3 * 19 * 3 * 19 * 3 * 19,)", "(3 * 19 * 19 * 19,)", "(3 * 2 * 3,)"], "outputs": ["[2]", "[2, 2]", "[2, 2, 2]", "[3, 19]", "[3, 3, 19, 19]", "[3, 3, 3, 19, 19, 19]", "[3, 19, 19, 19]", "[2, 3, 3]"], "test": null} {"task_id": "DREval/13", "entry_point": "max_element", "code": "\n\ndef max_element(l: list):\n \"\"\"Return maximum element in the list.\n >>> max_element([1, 2, 3])\n 3\n >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])\n 123\n \"\"\"\n m = l[0]\n for e in l:\n if e > m:\n m = e\n return m\n", "inputs": ["([1, 2, 3],)", "([5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10],)"], "outputs": ["3", "124"], "test": null} {"task_id": "DREval/14", "entry_point": "fizz_buzz", "code": "\n\ndef fizz_buzz(n: int):\n \"\"\"Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.\n >>> fizz_buzz(50)\n 0\n >>> fizz_buzz(78)\n 2\n >>> fizz_buzz(79)\n 3\n \"\"\"\n ns = []\n for i in range(n):\n if i % 11 == 0 or i % 13 == 0:\n ns.append(i)\n s = ''.join(list(map(str, ns)))\n ans = 0\n for c in s:\n ans += (c == '7')\n return ans\n", "inputs": ["(50,)", "(78,)", "(79,)", "(100,)", "(200,)", "(4000,)"], "outputs": ["0", "2", "3", "3", "6", "192"], "test": null} {"task_id": "DREval/15", "entry_point": "sort_even", "code": "\n\ndef sort_even(l: list):\n \"\"\"This function takes a list l and returns a list l' such that\n l' is identical to l in the odd indicies, while its values at the even indicies are equal\n to the values of the even indicies of l, but sorted.\n >>> sort_even([1, 2, 3])\n [1, 2, 3]\n >>> sort_even([5, 6, 3, 4])\n [3, 6, 5, 4]\n \"\"\"\n evens = l[::2]\n odds = l[1::2]\n evens.sort()\n ans = []\n for e, o in zip(evens, odds):\n ans.extend([e, o])\n if len(evens) > len(odds):\n ans.append(evens[-1])\n return ans\n", "inputs": ["([1, 2, 3],)", "([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10],)", "([5, 8, -12, 4, 23, 2, 3, 11, 12, -10],)"], "outputs": ["[1, 2, 3]", "[-10, 3, -5, 2, -3, 3, 5, 0, 9, 1, 123]", "[-12, 8, 3, 4, 5, 2, 12, 11, 23, -10]"], "test": null} {"task_id": "DREval/16", "entry_point": "prime_fib", "code": "\n\ndef prime_fib(n: int):\n \"\"\"\n prime_fib returns n-th number that is a Fibonacci number and it's also prime.\n >>> prime_fib(1)\n 2\n >>> prime_fib(2)\n 3\n >>> prime_fib(3)\n 5\n >>> prime_fib(4)\n 13\n >>> prime_fib(5)\n 89\n \"\"\"\n import math\n\n def is_prime(p):\n if p < 2:\n return False\n for k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):\n if p % k == 0:\n return False\n return True\n f = [0, 1]\n while True:\n f.append(f[-1] + f[-2])\n if is_prime(f[-1]):\n n -= 1\n if n == 0:\n return f[-1]\n", "inputs": ["(1,)", "(2,)", "(3,)", "(4,)", "(5,)", "(6,)", "(7,)", "(8,)", "(9,)", "(10,)"], "outputs": ["2", "3", "5", "13", "89", "233", "1597", "28657", "514229", "433494437"], "test": null} {"task_id": "DREval/17", "entry_point": "change_base", "code": "\n\ndef change_base(x: int, base: int):\n \"\"\"Change numerical base of input number x to base.\n return string representation after the conversion.\n base numbers are less than 10.\n >>> change_base(8, 3)\n '22'\n >>> change_base(8, 2)\n '1000'\n >>> change_base(7, 2)\n '111'\n \"\"\"\n ret = \"\"\n while x > 0:\n ret = str(x % base) + ret\n x //= base\n return ret\n", "inputs": ["(8, 3,)", "(9, 3,)", "(234, 2,)", "(16, 2,)", "(8, 2,)", "(7, 2,)"], "outputs": ["'22'", "'100'", "'11101010'", "'10000'", "'1000'", "'111'"], "test": null} {"task_id": "DREval/18", "entry_point": "fib4", "code": "\n\ndef fib4(n: int):\n \"\"\"The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:\n fib4(0) -> 0\n fib4(1) -> 0\n fib4(2) -> 2\n fib4(3) -> 0\n fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).\n Please write a function to efficiently compute the n-th element of the fib4 number sequence. Do not use recursion.\n >>> fib4(5)\n 4\n >>> fib4(6)\n 8\n >>> fib4(7)\n 14\n \"\"\"\n results = [0, 0, 2, 0]\n if n < 4:\n return results[n]\n\n for _ in range(4, n + 1):\n results.append(results[-1] + results[-2] + results[-3] + results[-4])\n results.pop(0)\n\n return results[-1]\n", "inputs": ["(5,)", "(8,)", "(10,)", "(12,)"], "outputs": ["4", "28", "104", "386"], "test": null} {"task_id": "DREval/19", "entry_point": "median", "code": "\n\ndef median(l: list):\n \"\"\"Return median of elements in the list l.\n >>> median([3, 1, 2, 4, 5])\n 3\n >>> median([-10, 4, 6, 1000, 10, 20])\n 15.0\n \"\"\"\n l = sorted(l)\n if len(l) % 2 == 1:\n return l[len(l) // 2]\n else:\n return (l[len(l) // 2 - 1] + l[len(l) // 2]) / 2.0\n", "inputs": ["([3, 1, 2, 4, 5],)", "([-10, 4, 6, 1000, 10, 20],)", "([5],)", "([6, 5],)", "([8, 1, 3, 9, 9, 2, 7],)"], "outputs": ["3", "8.0", "5", "5.5", "7"], "test": null} {"task_id": "DREval/20", "entry_point": "modp", "code": "\n\ndef modp(n: int, p: int):\n \"\"\"Return 2^n modulo p (be aware of numerics).\n >>> modp(3, 5)\n 3\n >>> modp(1101, 101)\n 2\n >>> modp(0, 101)\n 1\n >>> modp(3, 11)\n 8\n >>> modp(100, 101)\n 1\n \"\"\"\n ret = 1\n for i in range(n):\n ret = (2 * ret) % p\n return ret\n", "inputs": ["(3, 5,)", "(1101, 101,)", "(0, 101,)", "(3, 11,)", "(100, 101,)", "(30, 5,)", "(31, 5,)"], "outputs": ["3", "2", "1", "8", "1", "4", "3"], "test": null} {"task_id": "DREval/21", "entry_point": "correct_bracketing", "code": "\n\ndef correct_bracketing(brackets: str):\n \"\"\" brackets is a string of \"<\" and \">\".\n return True if every opening bracket has a corresponding closing bracket.\n\n >>> correct_bracketing(\"<\")\n False\n >>> correct_bracketing(\"<>\")\n True\n >>> correct_bracketing(\"<<><>>\")\n True\n >>> correct_bracketing(\"><<>\")\n False\n \"\"\"\n depth = 0\n for b in brackets:\n if b == \"<\":\n depth += 1\n else:\n depth -= 1\n if depth < 0:\n return False\n return depth == 0\n", "inputs": ["('<>',)", "('<<><>>',)", "('<><><<><>><>',)", "('<><><<<><><>><>><<><><<>>>',)", "('<<<><>>>>',)", "('><<>',)", "('<',)", "('<<<<',)", "('>',)", "('<<>',)", "('<><><<><>><>><<>',)", "('<><><<><>><>>><>',)"], "outputs": ["True", "True", "True", "True", "False", "False", "False", "False", "False", "False", "False", "False"], "test": null} {"task_id": "DREval/22", "entry_point": "common", "code": "\n\ndef common(l1: list, l2: list):\n \"\"\"Return sorted unique common elements for two lists.\n >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])\n [1, 5, 653]\n >>> common([5, 3, 2, 8], [3, 2])\n [2, 3]\n\n \"\"\"\n ret = set()\n for e1 in l1:\n for e2 in l2:\n if e1 == e2:\n ret.add(e1)\n return sorted(list(ret))\n", "inputs": ["([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121],)", "([5, 3, 2, 8], [3, 2],)", "([4, 3, 2, 8], [3, 2, 4],)", "([4, 3, 2, 8], [],)"], "outputs": ["[1, 5, 653]", "[2, 3]", "[2, 3, 4]", "[]"], "test": null} {"task_id": "DREval/23", "entry_point": "largest_prime_factor", "code": "\n\ndef largest_prime_factor(n: int):\n \"\"\"Return the largest prime factor of n. Assume n > 1 and is not a prime.\n >>> largest_prime_factor(13195)\n 29\n >>> largest_prime_factor(2048)\n 2\n \"\"\"\n def is_prime(k):\n if k < 2:\n return False\n for i in range(2, k - 1):\n if k % i == 0:\n return False\n return True\n largest = 1\n for j in range(2, n + 1):\n if n % j == 0 and is_prime(j):\n largest = max(largest, j)\n return largest\n", "inputs": ["(15,)", "(27,)", "(63,)", "(330,)", "(13195,)"], "outputs": ["5", "3", "7", "11", "29"], "test": null} {"task_id": "DREval/24", "entry_point": "correct_bracketing", "code": "\n\ndef correct_bracketing(brackets: str):\n \"\"\" brackets is a string of \"(\" and \")\".\n return True if every opening bracket has a corresponding closing bracket.\n\n >>> correct_bracketing(\"(\")\n False\n >>> correct_bracketing(\"()\")\n True\n >>> correct_bracketing(\"(()())\")\n True\n >>> correct_bracketing(\")(()\")\n False\n \"\"\"\n depth = 0\n for b in brackets:\n if b == \"(\":\n depth += 1\n else:\n depth -= 1\n if depth < 0:\n return False\n return depth == 0\n", "inputs": ["('()',)", "('(()())',)", "('()()(()())()',)", "('()()((()()())())(()()(()))',)", "('((()())))',)", "(')(()',)", "('(',)", "('((((',)", "(')',)", "('(()',)", "('()()(()())())(()',)", "('()()(()())()))()',)"], "outputs": ["True", "True", "True", "True", "False", "False", "False", "False", "False", "False", "False", "False"], "test": null} {"task_id": "DREval/25", "entry_point": "vowels_count", "code": "\nFIX = \"\"\"\nAdd more test cases.\n\"\"\"\n\ndef vowels_count(s):\n \"\"\"Write a function vowels_count which takes a string representing\n a word as input and returns the number of vowels in the string.\n Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a\n vowel, but only when it is at the end of the given word.\n\n Example:\n >>> vowels_count(\"abcde\")\n 2\n >>> vowels_count(\"ACEDY\")\n 3\n \"\"\"\n vowels = \"aeiouAEIOU\"\n n_vowels = sum(c in vowels for c in s)\n if s[-1] == 'y' or s[-1] == 'Y':\n n_vowels += 1\n return n_vowels\n", "inputs": ["('abcde',)", "('Alone',)", "('key',)", "('bye',)", "('keY',)", "('bYe',)", "('ACEDY',)"], "outputs": ["2", "3", "2", "1", "2", "1", "3"], "test": null} {"task_id": "DREval/26", "entry_point": "circular_shift", "code": "\ndef circular_shift(x, shift):\n \"\"\"Circular shift the digits of the integer x, shift the digits right by shift\n and return the result as a string.\n If shift > number of digits, return digits reversed.\n >>> circular_shift(12, 1)\n \"21\"\n >>> circular_shift(12, 2)\n \"12\"\n \"\"\"\n s = str(x)\n if shift > len(s):\n return s[::-1]\n else:\n return s[len(s) - shift:] + s[:len(s) - shift]\n", "inputs": ["(100, 2,)", "(12, 2,)", "(97, 8,)", "(12, 1,)", "(11, 101,)"], "outputs": ["'001'", "'12'", "'79'", "'21'", "'11'"], "test": null} {"task_id": "DREval/27", "entry_point": "fruit_distribution", "code": "\ndef fruit_distribution(s,n):\n \"\"\"\n In this task, you will be given a string that represents a number of apples and oranges \n that are distributed in a basket of fruit this basket contains \n apples, oranges, and mango fruits. Given the string that represents the total number of \n the oranges and apples and an integer that represent the total number of the fruits \n in the basket return the number of the mango fruits in the basket.\n for examble:\n fruit_distribution(\"5 apples and 6 oranges\", 19) ->19 - 5 - 6 = 8\n fruit_distribution(\"0 apples and 1 oranges\",3) -> 3 - 0 - 1 = 2\n fruit_distribution(\"2 apples and 3 oranges\", 100) -> 100 - 2 - 3 = 95\n fruit_distribution(\"100 apples and 1 oranges\",120) -> 120 - 100 - 1 = 19\n \"\"\"\n lis = list()\n for i in s.split(' '):\n if i.isdigit():\n lis.append(int(i))\n return n - sum(lis)\n", "inputs": ["('5 apples and 6 oranges', 19,)", "('5 apples and 6 oranges', 21,)", "('0 apples and 1 oranges', 3,)", "('1 apples and 0 oranges', 3,)", "('2 apples and 3 oranges', 100,)", "('2 apples and 3 oranges', 5,)", "('1 apples and 100 oranges', 120,)"], "outputs": ["8", "10", "2", "2", "95", "0", "19"], "test": null} {"task_id": "DREval/28", "entry_point": "pluck", "code": "\ndef pluck(arr):\n \"\"\"\n \"Given an array representing a branch of a tree that has non-negative integer nodes\n your task is to pluck one of the nodes and return it.\n The plucked node should be the node with the smallest even value.\n If multiple nodes with the same smallest even value are found return the node that has smallest index.\n\n The plucked node should be returned in a list, [ smalest_value, its index ],\n If there are no even values or the given array is empty, return [].\n\n Example 1:\n Input: [4,2,3]\n Output: [2, 1]\n Explanation: 2 has the smallest even value, and 2 has the smallest index.\n\n Example 2:\n Input: [1,2,3]\n Output: [2, 1]\n Explanation: 2 has the smallest even value, and 2 has the smallest index. \n\n Example 3:\n Input: []\n Output: []\n \n Example 4:\n Input: [5, 0, 3, 0, 4, 2]\n Output: [0, 1]\n Explanation: 0 is the smallest value, but there are two zeros,\n so we will choose the first zero, which has the smallest index.\n\n Constraints:\n * 1 <= nodes.length <= 10000\n * 0 <= node.value\n \"\"\"\n if(len(arr) == 0): return []\n evens = list(filter(lambda x: x%2 == 0, arr))\n if(evens == []): return []\n return [min(evens), arr.index(min(evens))]\n", "inputs": ["([4, 2, 3],)", "([1, 2, 3],)", "([],)", "([5, 0, 3, 0, 4, 2],)", "([1, 2, 3, 0, 5, 3],)", "([5, 4, 8, 4, 8],)", "([7, 6, 7, 1],)", "([7, 9, 7, 1],)"], "outputs": ["[2, 1]", "[2, 1]", "[]", "[0, 1]", "[0, 3]", "[4, 1]", "[6, 1]", "[]"], "test": null} {"task_id": "DREval/29", "entry_point": "search", "code": "\ndef search(lst):\n '''\n You are given a non-empty list of positive integers. Return the greatest integer that is greater than \n zero, and has a frequency greater than or equal to the value of the integer itself. \n The frequency of an integer is the number of times it appears in the list.\n If no such a value exist, return -1.\n Examples:\n search([4, 1, 2, 2, 3, 1]) == 2\n search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3\n search([5, 5, 4, 4, 4]) == -1\n '''\n frq = [0] * (max(lst) + 1)\n for i in lst:\n frq[i] += 1;\n\n ans = -1\n for i in range(1, len(frq)):\n if frq[i] >= i:\n ans = i\n \n return ans\n", "inputs": ["([5, 5, 5, 5, 1],)", "([4, 1, 4, 1, 4, 4],)", "([3, 3],)", "([8, 8, 8, 8, 8, 8, 8, 8],)", "([2, 3, 3, 2, 2],)", "([2, 7, 8, 8, 4, 8, 7, 3, 9, 6, 5, 10, 4, 3, 6, 7, 1, 7, 4, 10, 8, 1],)", "([3, 2, 8, 2],)", "([6, 7, 1, 8, 8, 10, 5, 8, 5, 3, 10],)", "([8, 8, 3, 6, 5, 6, 4],)", "([6, 9, 6, 7, 1, 4, 7, 1, 8, 8, 9, 8, 10, 10, 8, 4, 10, 4, 10, 1, 2, 9, 5, 7, 9],)", "([1, 9, 10, 1, 3],)", "([6, 9, 7, 5, 8, 7, 5, 3, 7, 5, 10, 10, 3, 6, 10, 2, 8, 6, 5, 4, 9, 5, 3, 10],)", "([1],)", "([8, 8, 10, 6, 4, 3, 5, 8, 2, 4, 2, 8, 4, 6, 10, 4, 2, 1, 10, 2, 1, 1, 5],)", "([2, 10, 4, 8, 2, 10, 5, 1, 2, 9, 5, 5, 6, 3, 8, 6, 4, 10],)", "([1, 6, 10, 1, 6, 9, 10, 8, 6, 8, 7, 3],)", "([9, 2, 4, 1, 5, 1, 5, 2, 5, 7, 7, 7, 3, 10, 1, 5, 4, 2, 8, 4, 1, 9, 10, 7, 10, 2, 8, 10, 9, 4],)", "([2, 6, 4, 2, 8, 7, 5, 6, 4, 10, 4, 6, 3, 7, 8, 8, 3, 1, 4, 2, 2, 10, 7],)", "([9, 8, 6, 10, 2, 6, 10, 2, 7, 8, 10, 3, 8, 2, 6, 2, 3, 1],)", "([5, 5, 3, 9, 5, 6, 3, 2, 8, 5, 6, 10, 10, 6, 8, 4, 10, 7, 7, 10, 8],)", "([10],)", "([9, 7, 7, 2, 4, 7, 2, 10, 9, 7, 5, 7, 2],)", "([5, 4, 10, 2, 1, 1, 10, 3, 6, 1, 8],)", "([7, 9, 9, 9, 3, 4, 1, 5, 9, 1, 2, 1, 1, 10, 7, 5, 6, 7, 6, 7, 7, 6],)", "([3, 10, 10, 9, 2],)"], "outputs": ["1", "4", "-1", "8", "2", "1", "2", "1", "-1", "1", "1", "5", "1", "4", "2", "1", "4", "4", "2", "-1", "-1", "2", "1", "1", "-1"], "test": null} {"task_id": "DREval/30", "entry_point": "strange_sort_list", "code": "\ndef strange_sort_list(lst):\n '''\n Given list of integers, return list in strange order.\n Strange sorting, is when you start with the minimum value,\n then maximum of the remaining integers, then minimum and so on.\n\n Examples:\n strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]\n strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]\n strange_sort_list([]) == []\n '''\n res, switch = [], True\n while lst:\n res.append(min(lst) if switch else max(lst))\n lst.remove(res[-1])\n switch = not switch\n return res\n", "inputs": ["([1, 2, 3, 4],)", "([5, 6, 7, 8, 9],)", "([1, 2, 3, 4, 5],)", "([5, 6, 7, 8, 9, 1],)", "([5, 5, 5, 5],)", "([],)", "([1, 2, 3, 4, 5, 6, 7, 8],)", "([0, 2, 2, 2, 5, 5, -5, -5],)", "([111111],)"], "outputs": ["[1, 4, 2, 3]", "[5, 9, 6, 8, 7]", "[1, 5, 2, 4, 3]", "[1, 9, 5, 8, 6, 7]", "[5, 5, 5, 5]", "[]", "[1, 8, 2, 7, 3, 6, 4, 5]", "[-5, 5, -5, 5, 0, 2, 2, 2]", "[111111]"], "test": null} {"task_id": "DREval/31", "entry_point": "will_it_fly", "code": "\ndef will_it_fly(q,w):\n '''\n Write a function that returns True if the object q will fly, and False otherwise.\n The object q will fly if it's balanced (it is a palindromic list) and the sum of its elements is less than or equal the maximum possible weight w.\n\n Example:\n will_it_fly([1, 2], 5) \u279e False \n # 1+2 is less than the maximum possible weight, but it's unbalanced.\n\n will_it_fly([3, 2, 3], 1) \u279e False\n # it's balanced, but 3+2+3 is more than the maximum possible weight.\n\n will_it_fly([3, 2, 3], 9) \u279e True\n # 3+2+3 is less than the maximum possible weight, and it's balanced.\n\n will_it_fly([3], 5) \u279e True\n # 3 is less than the maximum possible weight, and it's balanced.\n '''\n if sum(q) > w:\n return False\n\n i, j = 0, len(q)-1\n while i true\n is_simple_power(2, 2) => true\n is_simple_power(8, 2) => true\n is_simple_power(3, 2) => false\n is_simple_power(3, 1) => false\n is_simple_power(5, 3) => false\n \"\"\"\n if (n == 1): \n return (x == 1) \n power = 1\n while (power < x): \n power = power * n \n return (power == x) \n", "inputs": ["(16, 2,)", "(143214, 16,)", "(4, 2,)", "(9, 3,)", "(16, 4,)", "(24, 2,)", "(128, 4,)", "(12, 6,)", "(1, 1,)", "(1, 12,)"], "outputs": ["True", "False", "True", "True", "True", "False", "False", "False", "True", "True"], "test": null} {"task_id": "DREval/35", "entry_point": "hex_key", "code": "\ndef hex_key(num):\n \"\"\"You have been tasked to write a function that receives \n a hexadecimal number as a string and counts the number of hexadecimal \n digits that are primes (prime number, or a prime, is a natural number \n greater than 1 that is not a product of two smaller natural numbers).\n Hexadecimal digits are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.\n Prime numbers are 2, 3, 5, 7, 11, 13, 17,...\n So you have to determine a number of the following digits: 2, 3, 5, 7, \n B (=decimal 11), D (=decimal 13).\n Note: you may assume the input is always correct or empty string, \n and symbols A,B,C,D,E,F are always uppercase.\n Examples:\n For num = \"AB\" the output should be 1.\n For num = \"1077E\" the output should be 2.\n For num = \"ABED1A33\" the output should be 4.\n For num = \"123456789ABCDEF0\" the output should be 6.\n For num = \"2020\" the output should be 2.\n \"\"\"\n primes = ('2', '3', '5', '7', 'B', 'D')\n total = 0\n for i in range(0, len(num)):\n if num[i] in primes:\n total += 1\n return total\n", "inputs": ["('AB',)", "('1077E',)", "('ABED1A33',)", "('2020',)", "('123456789ABCDEF0',)", "('112233445566778899AABBCCDDEEFF00',)", "([],)"], "outputs": ["1", "2", "4", "2", "6", "12", "0"], "test": null} {"task_id": "DREval/36", "entry_point": "numerical_letter_grade", "code": "\ndef numerical_letter_grade(grades):\n \"\"\"It is the last week of the semester and the teacher has to give the grades\n to students. The teacher has been making her own algorithm for grading.\n The only problem is, she has lost the code she used for grading.\n She has given you a list of GPAs for some students and you have to write \n a function that can output a list of letter grades using the following table:\n GPA | Letter grade\n 4.0 A+\n > 3.7 A \n > 3.3 A- \n > 3.0 B+\n > 2.7 B \n > 2.3 B-\n > 2.0 C+\n > 1.7 C\n > 1.3 C-\n > 1.0 D+ \n > 0.7 D \n > 0.0 D-\n 0.0 E\n \n\n Example:\n grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']\n \"\"\"\n\n \n letter_grade = []\n for gpa in grades:\n if gpa == 4.0:\n letter_grade.append(\"A+\")\n elif gpa > 3.7:\n letter_grade.append(\"A\")\n elif gpa > 3.3:\n letter_grade.append(\"A-\")\n elif gpa > 3.0:\n letter_grade.append(\"B+\")\n elif gpa > 2.7:\n letter_grade.append(\"B\")\n elif gpa > 2.3:\n letter_grade.append(\"B-\")\n elif gpa > 2.0:\n letter_grade.append(\"C+\")\n elif gpa > 1.7:\n letter_grade.append(\"C\")\n elif gpa > 1.3:\n letter_grade.append(\"C-\")\n elif gpa > 1.0:\n letter_grade.append(\"D+\")\n elif gpa > 0.7:\n letter_grade.append(\"D\")\n elif gpa > 0.0:\n letter_grade.append(\"D-\")\n else:\n letter_grade.append(\"E\")\n return letter_grade\n", "inputs": ["([4.0, 3, 1.7, 2, 3.5],)", "([1.2],)", "([0.5],)", "([0.0],)", "([1, 0.3, 1.5, 2.8, 3.3],)", "([0, 0.7],)"], "outputs": ["['A+', 'B', 'C-', 'C', 'A-']", "['D+']", "['D-']", "['E']", "['D', 'D-', 'C-', 'B', 'B+']", "['E', 'D-']"], "test": null} {"task_id": "DREval/37", "entry_point": "prime_length", "code": "\ndef prime_length(string):\n \"\"\"Write a function that takes a string and returns True if the string\n length is a prime number or False otherwise\n Examples\n prime_length('Hello') == True\n prime_length('abcdcba') == True\n prime_length('kittens') == True\n prime_length('orange') == False\n \"\"\"\n l = len(string)\n if l == 0 or l == 1:\n return False\n for i in range(2, l):\n if l % i == 0:\n return False\n return True\n", "inputs": ["('Hello',)", "('abcdcba',)", "('kittens',)", "('orange',)", "('wow',)", "('world',)", "('MadaM',)", "('Wow',)", "('',)", "('HI',)", "('go',)", "('gogo',)", "('aaaaaaaaaaaaaaa',)", "('Madam',)", "('M',)", "('0',)"], "outputs": ["True", "True", "True", "False", "True", "True", "True", "True", "False", "True", "True", "False", "False", "True", "False", "False"], "test": null} {"task_id": "DREval/38", "entry_point": "encrypt", "code": "\ndef encrypt(s):\n \"\"\"Create a function encrypt that takes a string as an argument and\n returns a string encrypted with the alphabet being rotated. \n The alphabet should be rotated in a manner such that the letters \n shift down by two multiplied to two places.\n For example:\n encrypt('hi') returns 'lm'\n encrypt('asdfghjkl') returns 'ewhjklnop'\n encrypt('gf') returns 'kj'\n encrypt('et') returns 'ix'\n \"\"\"\n d = 'abcdefghijklmnopqrstuvwxyz'\n out = ''\n for c in s:\n if c in d:\n out += d[(d.index(c)+2*2) % 26]\n else:\n out += c\n return out\n", "inputs": ["('hi',)", "('asdfghjkl',)", "('gf',)", "('et',)", "('faewfawefaewg',)", "('hellomyfriend',)", "('dxzdlmnilfuhmilufhlihufnmlimnufhlimnufhfucufh',)", "('a',)"], "outputs": ["'lm'", "'ewhjklnop'", "'kj'", "'ix'", "'jeiajeaijeiak'", "'lippsqcjvmirh'", "'hbdhpqrmpjylqmpyjlpmlyjrqpmqryjlpmqryjljygyjl'", "'e'"], "test": null} {"task_id": "DREval/39", "entry_point": "skjkasdkd", "code": "\n\ndef skjkasdkd(lst):\n \"\"\"You are given a list of integers.\n You need to find the largest prime value and return the sum of its digits.\n\n Examples:\n For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10\n For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output should be 25\n For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13\n For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11\n For lst = [0,81,12,3,1,21] the output should be 3\n For lst = [0,8,1,2,1,7] the output should be 7\n \"\"\"\n def isPrime(n):\n for i in range(2,int(n**0.5)+1):\n if n%i==0:\n return False\n\n return True\n maxx = 0\n i = 0\n while i < len(lst):\n if(lst[i] > maxx and isPrime(lst[i])):\n maxx = lst[i]\n i+=1\n result = sum(int(digit) for digit in str(maxx))\n return result\n\n", "inputs": ["([0, 3, 2, 1, 3, 5, 7, 4, 5, 5, 5, 2, 181, 32, 4, 32, 3, 2, 32, 324, 4, 3],)", "([1, 0, 1, 8, 2, 4597, 2, 1, 3, 40, 1, 2, 1, 2, 4, 2, 5, 1],)", "([1, 3, 1, 32, 5107, 34, 83278, 109, 163, 23, 2323, 32, 30, 1, 9, 3],)", "([0, 724, 32, 71, 99, 32, 6, 0, 5, 91, 83, 0, 5, 6],)", "([0, 81, 12, 3, 1, 21],)", "([0, 8, 1, 2, 1, 7],)", "([8191],)", "([8191, 123456, 127, 7],)", "([127, 97, 8192],)"], "outputs": ["10", "25", "13", "11", "3", "7", "19", "19", "10"], "test": null} {"task_id": "DREval/40", "entry_point": "count_up_to", "code": "\ndef count_up_to(n):\n \"\"\"Implement a function that takes an non-negative integer and returns an array of the first n\n integers that are prime numbers and less than n.\n for example:\n count_up_to(5) => [2,3]\n count_up_to(11) => [2,3,5,7]\n count_up_to(0) => []\n count_up_to(20) => [2,3,5,7,11,13,17,19]\n count_up_to(1) => []\n count_up_to(18) => [2,3,5,7,11,13,17]\n \"\"\"\n primes = []\n for i in range(2, n):\n is_prime = True\n for j in range(2, i):\n if i % j == 0:\n is_prime = False\n break\n if is_prime:\n primes.append(i)\n return primes\n\n", "inputs": ["(5,)", "(6,)", "(7,)", "(10,)", "(0,)", "(22,)", "(1,)", "(18,)", "(47,)", "(101,)"], "outputs": ["[2, 3]", "[2, 3, 5]", "[2, 3, 5]", "[2, 3, 5, 7]", "[]", "[2, 3, 5, 7, 11, 13, 17, 19]", "[]", "[2, 3, 5, 7, 11, 13, 17]", "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43]", "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]"], "test": null} {"task_id": "DREval/41", "entry_point": "count_upper", "code": "\ndef count_upper(s):\n \"\"\"\n Given a string s, count the number of uppercase vowels in even indices.\n \n For example:\n count_upper('aBCdEf') returns 1\n count_upper('abcdefg') returns 0\n count_upper('dBBE') returns 0\n \"\"\"\n count = 0\n for i in range(0,len(s),2):\n if s[i] in \"AEIOU\":\n count += 1\n return count\n", "inputs": ["('aBCdEf',)", "('abcdefg',)", "('dBBE',)", "('B',)", "('U',)", "('',)", "('EEEE',)"], "outputs": ["1", "0", "0", "0", "1", "0", "2"], "test": null} {"task_id": "DREval/42", "entry_point": "closest_integer", "code": "\ndef closest_integer(value):\n '''\n Create a function that takes a value (string) representing a number\n and returns the closest integer to it. If the number is equidistant\n from two integers, round it away from zero.\n\n Examples\n >>> closest_integer(\"10\")\n 10\n >>> closest_integer(\"15.3\")\n 15\n\n Note:\n Rounding away from zero means that if the given number is equidistant\n from two integers, the one you should return is the one that is the\n farthest from zero. For example closest_integer(\"14.5\") should\n return 15 and closest_integer(\"-14.5\") should return -15.\n '''\n from math import floor, ceil\n\n if value.count('.') == 1:\n # remove trailing zeros\n while (value[-1] == '0'):\n value = value[:-1]\n\n num = float(value)\n if value[-2:] == '.5':\n if num > 0:\n res = ceil(num)\n else:\n res = floor(num)\n elif len(value) > 0:\n res = int(round(num))\n else:\n res = 0\n\n return res\n\n", "inputs": ["('10',)", "('14.5',)", "('-15.5',)", "('15.3',)", "('0',)"], "outputs": ["10", "15", "-16", "15", "0"], "test": null} {"task_id": "DREval/43", "entry_point": "words_string", "code": "\ndef words_string(s):\n \"\"\"\n You will be given a string of words separated by commas or spaces. Your task is\n to split the string into words and return an array of the words.\n \n For example:\n words_string(\"Hi, my name is John\") == [\"Hi\", \"my\", \"name\", \"is\", \"John\"]\n words_string(\"One, two, three, four, five, six\") == [\"One\", \"two\", \"three\", \"four\", \"five\", \"six\"]\n \"\"\"\n if not s:\n return []\n\n s_list = []\n\n for letter in s:\n if letter == ',':\n s_list.append(' ')\n else:\n s_list.append(letter)\n\n s_list = \"\".join(s_list)\n return s_list.split()\n", "inputs": ["('Hi, my name is John',)", "('One, two, three, four, five, six',)", "('Hi, my name',)", "('One,, two, three, four, five, six,',)", "('',)", "('ahmed , gamal',)"], "outputs": ["['Hi', 'my', 'name', 'is', 'John']", "['One', 'two', 'three', 'four', 'five', 'six']", "['Hi', 'my', 'name']", "['One', 'two', 'three', 'four', 'five', 'six']", "[]", "['ahmed', 'gamal']"], "test": null} {"task_id": "DREval/44", "entry_point": "rounded_avg", "code": "\ndef rounded_avg(n, m):\n \"\"\"You are given two positive integers n and m, and your task is to compute the\n average of the integers from n through m (including n and m). \n Round the answer to the nearest integer and convert that to binary.\n If n is greater than m, return -1.\n Example:\n rounded_avg(1, 5) => \"0b11\"\n rounded_avg(7, 5) => -1\n rounded_avg(10, 20) => \"0b1111\"\n rounded_avg(20, 33) => \"0b11010\"\n \"\"\"\n if m < n:\n return -1\n summation = 0\n for i in range(n, m+1):\n summation += i\n return bin(round(summation/(m - n + 1)))\n", "inputs": ["(1, 5,)", "(7, 13,)", "(964, 977,)", "(996, 997,)", "(560, 851,)", "(185, 546,)", "(362, 496,)", "(350, 902,)", "(197, 233,)", "(7, 5,)", "(5, 1,)", "(5, 5,)"], "outputs": ["'0b11'", "'0b1010'", "'0b1111001010'", "'0b1111100100'", "'0b1011000010'", "'0b101101110'", "'0b110101101'", "'0b1001110010'", "'0b11010111'", "-1", "-1", "'0b101'"], "test": null} {"task_id": "DREval/45", "entry_point": "unique_digits", "code": "\ndef unique_digits(x):\n \"\"\"Given a list of positive integers x. return a sorted list of all \n elements that hasn't any even digit.\n\n Note: Returned list should be sorted in increasing order.\n \n For example:\n >>> unique_digits([15, 33, 1422, 1])\n [1, 15, 33]\n >>> unique_digits([152, 323, 1422, 10])\n []\n \"\"\"\n odd_digit_elements = []\n for i in x:\n if all (int(c) % 2 == 1 for c in str(i)):\n odd_digit_elements.append(i)\n return sorted(odd_digit_elements)\n", "inputs": ["([15, 33, 1422, 1],)", "([152, 323, 1422, 10],)", "([12345, 2033, 111, 151],)", "([135, 103, 31],)"], "outputs": ["[1, 15, 33]", "[]", "[111, 151]", "[31, 135]"], "test": null} {"task_id": "DREval/46", "entry_point": "by_length", "code": "\ndef by_length(arr):\n \"\"\"\n Given an array of integers, sort the integers that are between 1 and 9 inclusive,\n reverse the resulting array, and then replace each digit by its corresponding name from\n \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\".\n\n For example:\n arr = [2, 1, 1, 4, 5, 8, 2, 3] \n -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8] \n -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]\n return [\"Eight\", \"Five\", \"Four\", \"Three\", \"Two\", \"Two\", \"One\", \"One\"]\n \n If the array is empty, return an empty array:\n arr = []\n return []\n \n If the array has any strange number ignore it:\n arr = [1, -1 , 55] \n -> sort arr -> [-1, 1, 55]\n -> reverse arr -> [55, 1, -1]\n return = ['One']\n \"\"\"\n dic = {\n 1: \"One\",\n 2: \"Two\",\n 3: \"Three\",\n 4: \"Four\",\n 5: \"Five\",\n 6: \"Six\",\n 7: \"Seven\",\n 8: \"Eight\",\n 9: \"Nine\",\n }\n sorted_arr = sorted(arr, reverse=True)\n new_arr = []\n for var in sorted_arr:\n try:\n new_arr.append(dic[var])\n except:\n pass\n return new_arr\n", "inputs": ["([2, 1, 1, 4, 5, 8, 2, 3],)", "([],)", "([1, -1, 55],)", "([1, -1, 3, 2],)", "([9, 4, 8],)"], "outputs": ["['Eight', 'Five', 'Four', 'Three', 'Two', 'Two', 'One', 'One']", "[]", "['One']", "['Three', 'Two', 'One']", "['Nine', 'Eight', 'Four']"], "test": null} {"task_id": "DREval/47", "entry_point": "f", "code": "\ndef f(n):\n \"\"\" Implement the function f that takes n as a parameter,\n and returns a list of size n, such that the value of the element at index i is the factorial of i if i is even\n or the sum of numbers from 1 to i otherwise.\n i starts from 1.\n the factorial of i is the multiplication of the numbers from 1 to i (1 * 2 * ... * i).\n Example:\n f(5) == [1, 2, 6, 24, 15]\n \"\"\"\n ret = []\n for i in range(1,n+1):\n if i%2 == 0:\n x = 1\n for j in range(1,i+1): x *= j\n ret += [x]\n else:\n x = 0\n for j in range(1,i+1): x += j\n ret += [x]\n return ret\n", "inputs": ["(5,)", "(7,)", "(1,)", "(3,)"], "outputs": ["[1, 2, 6, 24, 15]", "[1, 2, 6, 24, 15, 720, 28]", "[1]", "[1, 2, 6]"], "test": null} {"task_id": "DREval/48", "entry_point": "even_odd_palindrome", "code": "\ndef even_odd_palindrome(n):\n \"\"\"\n Given a positive integer n, return a tuple that has the number of even and odd\n integer palindromes that fall within the range(1, n), inclusive.\n\n Example 1:\n\n Input: 3\n Output: (1, 2)\n Explanation:\n Integer palindrome are 1, 2, 3. one of them is even, and two of them are odd.\n\n Example 2:\n\n Input: 12\n Output: (4, 6)\n Explanation:\n Integer palindrome are 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. four of them are even, and 6 of them are odd.\n\n Note:\n 1. 1 <= n <= 10^3\n 2. returned tuple has the number of even and odd integer palindromes respectively.\n \"\"\"\n def is_palindrome(n):\n return str(n) == str(n)[::-1]\n\n even_palindrome_count = 0\n odd_palindrome_count = 0\n\n for i in range(1, n+1):\n if i%2 == 1 and is_palindrome(i):\n odd_palindrome_count += 1\n elif i%2 == 0 and is_palindrome(i):\n even_palindrome_count += 1\n return (even_palindrome_count, odd_palindrome_count)\n", "inputs": ["(123,)", "(12,)", "(3,)", "(63,)", "(25,)", "(19,)", "(9,)", "(1,)"], "outputs": ["(8, 13)", "(4, 6)", "(1, 2)", "(6, 8)", "(5, 6)", "(4, 6)", "(4, 5)", "(0, 1)"], "test": null} {"task_id": "DREval/49", "entry_point": "count_nums", "code": "\ndef count_nums(arr):\n \"\"\"\n Write a function count_nums which takes an array of integers and returns\n the number of elements which has a sum of digits > 0.\n If a number is negative, then its first signed digit will be negative:\n e.g. -123 has signed digits -1, 2, and 3.\n >>> count_nums([]) == 0\n >>> count_nums([-1, 11, -11]) == 1\n >>> count_nums([1, 1, 2]) == 3\n \"\"\"\n def digits_sum(n):\n neg = 1\n if n < 0: n, neg = -1 * n, -1 \n n = [int(i) for i in str(n)]\n n[0] = n[0] * neg\n return sum(n)\n return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr])))\n", "inputs": ["([],)", "([-1, -2, 0],)", "([1, 1, 2, -2, 3, 4, 5],)", "([1, 6, 9, -6, 0, 1, 5],)", "([1, 100, 98, -7, 1, -1],)", "([12, 23, 34, -45, -56, 0],)", "([-0, 1 ** 0],)", "([1],)"], "outputs": ["0", "0", "6", "5", "4", "5", "1", "1"], "test": null} {"task_id": "DREval/50", "entry_point": "move_one_ball", "code": "\ndef move_one_ball(arr):\n \"\"\"We have an array 'arr' of N integers arr[1], arr[2], ..., arr[N].The\n numbers in the array will be randomly ordered. Your task is to determine if\n it is possible to get an array sorted in non-decreasing order by performing \n the following operation on the given array:\n You are allowed to perform right shift operation any number of times.\n \n One right shift operation means shifting all elements of the array by one\n position in the right direction. The last element of the array will be moved to\n the starting position in the array i.e. 0th index. \n\n If it is possible to obtain the sorted array by performing the above operation\n then return True else return False.\n If the given array is empty then return True.\n\n Note: The given list is guaranteed to have unique elements.\n\n For Example:\n \n move_one_ball([3, 4, 5, 1, 2])==>True\n Explanation: By performin 2 right shift operations, non-decreasing order can\n be achieved for the given array.\n move_one_ball([3, 5, 4, 1, 2])==>False\n Explanation:It is not possible to get non-decreasing order for the given\n array by performing any number of right shift operations.\n \n \"\"\"\n if len(arr)==0:\n return True\n sorted_array=sorted(arr)\n my_arr=[]\n \n min_value=min(arr)\n min_index=arr.index(min_value)\n my_arr=arr[min_index:]+arr[0:min_index]\n for i in range(len(arr)):\n if my_arr[i]!=sorted_array[i]:\n return False\n return True\n", "inputs": ["([3, 4, 5, 1, 2],)", "([3, 5, 10, 1, 2],)", "([4, 3, 1, 2],)", "([3, 5, 4, 1, 2],)", "([],)"], "outputs": ["True", "True", "False", "False", "True"], "test": null} {"task_id": "DREval/51", "entry_point": "exchange", "code": "\ndef exchange(lst1, lst2):\n \"\"\"In this problem, you will implement a function that takes two lists of numbers,\n and determines whether it is possible to perform an exchange of elements\n between them to make lst1 a list of only even numbers.\n There is no limit on the number of exchanged elements between lst1 and lst2.\n If it is possible to exchange elements between the lst1 and lst2 to make\n all the elements of lst1 to be even, return \"YES\".\n Otherwise, return \"NO\".\n For example:\n exchange([1, 2, 3, 4], [1, 2, 3, 4]) => \"YES\"\n exchange([1, 2, 3, 4], [1, 5, 3, 4]) => \"NO\"\n It is assumed that the input lists will be non-empty.\n \"\"\"\n odd = 0\n even = 0\n for i in lst1:\n if i%2 == 1:\n odd += 1\n for i in lst2:\n if i%2 == 0:\n even += 1\n if even >= odd:\n return \"YES\"\n return \"NO\"\n \n", "inputs": ["([1, 2, 3, 4], [1, 2, 3, 4],)", "([1, 2, 3, 4], [1, 5, 3, 4],)", "([1, 2, 3, 4], [2, 1, 4, 3],)", "([5, 7, 3], [2, 6, 4],)", "([5, 7, 3], [2, 6, 3],)", "([3, 2, 6, 1, 8, 9], [3, 5, 5, 1, 1, 1],)", "([100, 200], [200, 200],)"], "outputs": ["'YES'", "'NO'", "'YES'", "'YES'", "'NO'", "'NO'", "'YES'"], "test": null} {"task_id": "DREval/52", "entry_point": "histogram", "code": "\ndef histogram(test):\n \"\"\"Given a string representing a space separated lowercase letters, return a dictionary\n of the letter with the most repetition and containing the corresponding count.\n If several letters have the same occurrence, return all of them.\n \n Example:\n histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}\n histogram('a b b a') == {'a': 2, 'b': 2}\n histogram('a b c a b') == {'a': 2, 'b': 2}\n histogram('b b b b a') == {'b': 4}\n histogram('') == {}\n\n \"\"\"\n dict1={}\n list1=test.split(\" \")\n t=0\n\n for i in list1:\n if(list1.count(i)>t) and i!='':\n t=list1.count(i)\n if t>0:\n for i in list1:\n if(list1.count(i)==t):\n \n dict1[i]=t\n return dict1\n", "inputs": ["('a b b a',)", "('a b c a b',)", "('a b c d g',)", "('r t g',)", "('b b b b a',)", "('r t g',)", "('',)", "('a',)"], "outputs": ["{'a': 2, 'b': 2}", "{'a': 2, 'b': 2}", "{'a': 1, 'b': 1, 'c': 1, 'd': 1, 'g': 1}", "{'r': 1, 't': 1, 'g': 1}", "{'b': 4}", "{'r': 1, 't': 1, 'g': 1}", "{}", "{'a': 1}"], "test": null} {"task_id": "DREval/53", "entry_point": "odd_count", "code": "\ndef odd_count(lst):\n \"\"\"Given a list of strings, where each string consists of only digits, return a list.\n Each element i of the output should be \"the number of odd elements in the\n string i of the input.\" where all the i's should be replaced by the number\n of odd digits in the i'th string of the input.\n\n >>> odd_count(['1234567'])\n [\"the number of odd elements 4n the str4ng 4 of the 4nput.\"]\n >>> odd_count(['3',\"11111111\"])\n [\"the number of odd elements 1n the str1ng 1 of the 1nput.\",\n \"the number of odd elements 8n the str8ng 8 of the 8nput.\"]\n \"\"\"\n res = []\n for arr in lst:\n n = sum(int(d)%2==1 for d in arr)\n res.append(\"the number of odd elements \" + str(n) + \"n the str\"+ str(n) +\"ng \"+ str(n) +\" of the \"+ str(n) +\"nput.\")\n return res\n", "inputs": ["(['1234567'],)", "(['3', '11111111'],)", "(['271', '137', '314'],)"], "outputs": ["['the number of odd elements 4n the str4ng 4 of the 4nput.']", "['the number of odd elements 1n the str1ng 1 of the 1nput.', 'the number of odd elements 8n the str8ng 8 of the 8nput.']", "['the number of odd elements 2n the str2ng 2 of the 2nput.', 'the number of odd elements 3n the str3ng 3 of the 3nput.', 'the number of odd elements 2n the str2ng 2 of the 2nput.']"], "test": null} {"task_id": "DREval/54", "entry_point": "minSubArraySum", "code": "\ndef minSubArraySum(nums):\n \"\"\"\n Given an array of integers nums, find the minimum sum of any non-empty sub-array\n of nums.\n Example\n minSubArraySum([2, 3, 4, 1, 2, 4]) == 1\n minSubArraySum([-1, -2, -3]) == -6\n \"\"\"\n max_sum = 0\n s = 0\n for num in nums:\n s += -num\n if (s < 0):\n s = 0\n max_sum = max(s, max_sum)\n if max_sum == 0:\n max_sum = max(-i for i in nums)\n min_sum = -max_sum\n return min_sum\n", "inputs": ["([2, 3, 4, 1, 2, 4],)", "([-1, -2, -3],)", "([-1, -2, -3, 2, -10],)", "([-9999999999999999],)", "([0, 10, 20, 1000000],)", "([-1, -2, -3, 10, -5],)", "([100, -1, -2, -3, 10, -5],)", "([10, 11, 13, 8, 3, 4],)", "([100, -33, 32, -1, 0, -2],)", "([-10],)", "([7],)", "([1, -1],)"], "outputs": ["1", "-6", "-14", "-9999999999999999", "0", "-6", "-6", "3", "-33", "-10", "7", "-1"], "test": null} {"task_id": "DREval/55", "entry_point": "select_words", "code": "\ndef select_words(s, n):\n \"\"\"Given a string s and a natural number n, you have been tasked to implement \n a function that returns a list of all words from string s that contain exactly \n n consonants, in order these words appear in the string s.\n If the string s is empty then the function should return an empty list.\n Note: you may assume the input string contains only letters and spaces.\n Examples:\n select_words(\"Mary had a little lamb\", 4) ==> [\"little\"]\n select_words(\"Mary had a little lamb\", 3) ==> [\"Mary\", \"lamb\"]\n select_words(\"simple white space\", 2) ==> []\n select_words(\"Hello world\", 4) ==> [\"world\"]\n select_words(\"Uncle sam\", 3) ==> [\"Uncle\"]\n \"\"\"\n result = []\n for word in s.split():\n n_consonants = 0\n for i in range(0, len(word)):\n if word[i].lower() not in [\"a\",\"e\",\"i\",\"o\",\"u\"]:\n n_consonants += 1 \n if n_consonants == n:\n result.append(word)\n return result\n\n", "inputs": ["('Mary had a little lamb', 4,)", "('Mary had a little lamb', 3,)", "('simple white space', 2,)", "('Hello world', 4,)", "('Uncle sam', 3,)", "('', 4,)", "('a b c d e f', 1,)"], "outputs": ["['little']", "['Mary', 'lamb']", "[]", "['world']", "['Uncle']", "[]", "['b', 'c', 'd', 'f']"], "test": null} {"task_id": "DREval/56", "entry_point": "match_parens", "code": "\ndef match_parens(lst):\n '''\n You are given a list of two strings, both strings consist of open\n parentheses '(' or close parentheses ')' only.\n Your job is to check if it is possible to concatenate the two strings in\n some order, that the resulting string will be good.\n A string S is considered to be good if and only if all parentheses in S\n are balanced. For example: the string '(())()' is good, while the string\n '())' is not.\n Return 'Yes' if there's a way to make a good string, and return 'No' otherwise.\n\n Examples:\n match_parens(['()(', ')']) == 'Yes'\n match_parens([')', ')']) == 'No'\n '''\n def check(s):\n val = 0\n for i in s:\n if i == '(':\n val = val + 1\n else:\n val = val - 1\n if val < 0:\n return False\n return True if val == 0 else False\n\n S1 = lst[0] + lst[1]\n S2 = lst[1] + lst[0]\n return 'Yes' if check(S1) or check(S2) else 'No'\n", "inputs": ["(['()(', ')'],)", "([')', ')'],)", "(['(()(())', '())())'],)", "([')())', '(()()('],)", "(['(())))', '(()())(('],)", "(['()', '())'],)", "(['(()(', '()))()'],)", "(['((((', '((())'],)", "([')(()', '(()('],)", "([')(', ')('],)", "(['(', ')'],)", "([')', '('],)"], "outputs": ["'Yes'", "'No'", "'No'", "'Yes'", "'Yes'", "'No'", "'Yes'", "'No'", "'No'", "'No'", "'Yes'", "'Yes'"], "test": null} {"task_id": "DREval/57", "entry_point": "get_odd_collatz", "code": "\ndef get_odd_collatz(n):\n \"\"\"\n Given a positive integer n, return a sorted list that has the odd numbers in collatz sequence.\n\n The Collatz conjecture is a conjecture in mathematics that concerns a sequence defined\n as follows: start with any positive integer n. Then each term is obtained from the \n previous term as follows: if the previous term is even, the next term is one half of \n the previous term. If the previous term is odd, the next term is 3 times the previous\n term plus 1. The conjecture is that no matter what value of n, the sequence will always reach 1.\n\n Note: \n 1. Collatz(1) is [1].\n 2. returned list sorted in increasing order.\n\n For example:\n get_odd_collatz(5) returns [1, 5] # The collatz sequence for 5 is [5, 16, 8, 4, 2, 1], so the odd numbers are only 1, and 5.\n \"\"\"\n if n%2==0:\n odd_collatz = [] \n else:\n odd_collatz = [n]\n while n > 1:\n if n % 2 == 0:\n n = n/2\n else:\n n = n*3 + 1\n \n if n%2 == 1:\n odd_collatz.append(int(n))\n\n return sorted(odd_collatz)\n", "inputs": ["(14,)", "(5,)", "(12,)", "(1,)"], "outputs": ["[1, 5, 7, 11, 13, 17]", "[1, 5]", "[1, 3, 5]", "[1]"], "test": null} {"task_id": "DREval/58", "entry_point": "valid_date", "code": "\ndef valid_date(date):\n \"\"\"You have to write a function which validates a given date string and\n returns True if the date is valid otherwise False.\n The date is valid if all of the following rules are satisfied:\n 1. The date string is not empty.\n 2. The number of days is not less than 1 or higher than 31 days for months 1,3,5,7,8,10,12. And the number of days is not less than 1 or higher than 30 days for months 4,6,9,11. And, the number of days is not less than 1 or higher than 29 for the month 2.\n 3. The months should not be less than 1 or higher than 12.\n 4. The date should be in the format: mm-dd-yyyy\n\n for example: \n valid_date('03-11-2000') => True\n\n valid_date('15-01-2012') => False\n\n valid_date('04-0-2040') => False\n\n valid_date('06-04-2020') => True\n\n valid_date('06/04/2020') => False\n \"\"\"\n try:\n date = date.strip()\n month, day, year = date.split('-')\n month, day, year = int(month), int(day), int(year)\n if month < 1 or month > 12:\n return False\n if month in [1,3,5,7,8,10,12] and day < 1 or day > 31:\n return False\n if month in [4,6,9,11] and day < 1 or day > 30:\n return False\n if month == 2 and day < 1 or day > 29:\n return False\n except:\n return False\n\n return True\n", "inputs": ["('03-11-2000',)", "('15-01-2012',)", "('04-0-2040',)", "('06-04-2020',)", "('01-01-2007',)", "('03-32-2011',)", "('',)", "('04-31-3000',)", "('06-06-2005',)", "('21-31-2000',)", "('04-12-2003',)", "('04122003',)", "('20030412',)", "('2003-04',)", "('2003-04-12',)", "('04-2003',)"], "outputs": ["True", "False", "False", "True", "True", "False", "False", "False", "True", "False", "True", "False", "False", "False", "False", "False"], "test": null} {"task_id": "DREval/59", "entry_point": "is_sorted", "code": "\ndef is_sorted(lst):\n '''\n Given a list of numbers, return whether or not they are sorted\n in ascending order. If list has more than 1 duplicate of the same\n number, return False. Assume no negative numbers and only integers.\n\n Examples\n is_sorted([5]) \u279e True\n is_sorted([1, 2, 3, 4, 5]) \u279e True\n is_sorted([1, 3, 2, 4, 5]) \u279e False\n is_sorted([1, 2, 3, 4, 5, 6]) \u279e True\n is_sorted([1, 2, 3, 4, 5, 6, 7]) \u279e True\n is_sorted([1, 3, 2, 4, 5, 6, 7]) \u279e False\n is_sorted([1, 2, 2, 3, 3, 4]) \u279e True\n is_sorted([1, 2, 2, 2, 3, 4]) \u279e False\n '''\n count_digit = dict([(i, 0) for i in lst])\n for i in lst:\n count_digit[i]+=1 \n if any(count_digit[i] > 2 for i in lst):\n return False\n if all(lst[i-1] <= lst[i] for i in range(1, len(lst))):\n return True\n else:\n return False\n \n \n", "inputs": ["([5],)", "([1, 2, 3, 4, 5],)", "([1, 3, 2, 4, 5],)", "([1, 2, 3, 4, 5, 6],)", "([1, 2, 3, 4, 5, 6, 7],)", "([1, 3, 2, 4, 5, 6, 7],)", "([],)", "([1],)", "([3, 2, 1],)", "([1, 2, 2, 2, 3, 4],)", "([1, 2, 3, 3, 3, 4],)", "([1, 2, 2, 3, 3, 4],)", "([1, 2, 3, 4],)"], "outputs": ["True", "True", "False", "True", "True", "False", "True", "True", "False", "False", "False", "True", "True"], "test": null} {"task_id": "DREval/60", "entry_point": "intersection", "code": "\ndef intersection(interval1, interval2):\n \"\"\"You are given two intervals,\n where each interval is a pair of integers. For example, interval = (start, end) = (1, 2).\n The given intervals are closed which means that the interval (start, end)\n includes both start and end.\n For each given interval, it is assumed that its start is less or equal its end.\n Your task is to determine whether the length of intersection of these two \n intervals is a prime number.\n Example, the intersection of the intervals (1, 3), (2, 4) is (2, 3)\n which its length is 1, which not a prime number.\n If the length of the intersection is a prime number, return \"YES\",\n otherwise, return \"NO\".\n If the two intervals don't intersect, return \"NO\".\n\n\n [input/output] samples:\n intersection((1, 2), (2, 3)) ==> \"NO\"\n intersection((-1, 1), (0, 4)) ==> \"NO\"\n intersection((-3, -1), (-5, 5)) ==> \"YES\"\n \"\"\"\n def is_prime(num):\n if num == 1 or num == 0:\n return False\n if num == 2:\n return True\n for i in range(2, num):\n if num%i == 0:\n return False\n return True\n\n l = max(interval1[0], interval2[0])\n r = min(interval1[1], interval2[1])\n length = r - l\n if length > 0 and is_prime(length):\n return \"YES\"\n return \"NO\"\n", "inputs": ["((1, 2), (2, 3),)", "((-1, 1), (0, 4),)", "((-3, -1), (-5, 5),)", "((-2, 2), (-4, 0),)", "((-11, 2), (-1, -1),)", "((1, 2), (3, 5),)", "((1, 2), (1, 2),)", "((-2, -2), (-3, -2),)"], "outputs": ["'NO'", "'NO'", "'YES'", "'YES'", "'NO'", "'NO'", "'NO'", "'NO'"], "test": null} {"task_id": "DREval/61", "entry_point": "minPath", "code": "\ndef minPath(grid, k):\n \"\"\"\n Given a grid with N rows and N columns (N >= 2) and a positive integer k, \n each cell of the grid contains a value. Every integer in the range [1, N * N]\n inclusive appears exactly once on the cells of the grid.\n\n You have to find the minimum path of length k in the grid. You can start\n from any cell, and in each step you can move to any of the neighbor cells,\n in other words, you can go to cells which share an edge with you current\n cell.\n Please note that a path of length k means visiting exactly k cells (not\n necessarily distinct).\n You CANNOT go off the grid.\n A path A (of length k) is considered less than a path B (of length k) if\n after making the ordered lists of the values on the cells that A and B go\n through (let's call them lst_A and lst_B), lst_A is lexicographically less\n than lst_B, in other words, there exist an integer index i (1 <= i <= k)\n such that lst_A[i] < lst_B[i] and for any j (1 <= j < i) we have\n lst_A[j] = lst_B[j].\n It is guaranteed that the answer is unique.\n Return an ordered list of the values on the cells that the minimum path go through.\n\n Examples:\n\n Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3\n Output: [1, 2, 1]\n\n Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1\n Output: [1]\n \"\"\"\n n = len(grid)\n val = n * n + 1\n for i in range(n):\n for j in range(n):\n if grid[i][j] == 1:\n temp = []\n if i != 0:\n temp.append(grid[i - 1][j])\n\n if j != 0:\n temp.append(grid[i][j - 1])\n\n if i != n - 1:\n temp.append(grid[i + 1][j])\n\n if j != n - 1:\n temp.append(grid[i][j + 1])\n\n val = min(temp)\n\n ans = []\n for i in range(k):\n if i % 2 == 0:\n ans.append(1)\n else:\n ans.append(val)\n return ans\n", "inputs": ["([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3,)", "([[5, 9, 3], [4, 1, 6], [7, 8, 2]], 1,)", "([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]], 4,)", "([[6, 4, 13, 10], [5, 7, 12, 1], [3, 16, 11, 15], [8, 14, 9, 2]], 7,)", "([[8, 14, 9, 2], [6, 4, 13, 15], [5, 7, 1, 12], [3, 10, 11, 16]], 5,)", "([[11, 8, 7, 2], [5, 16, 14, 4], [9, 3, 15, 6], [12, 13, 10, 1]], 9,)", "([[12, 13, 10, 1], [9, 3, 15, 6], [5, 16, 14, 4], [11, 8, 7, 2]], 12,)", "([[2, 7, 4], [3, 1, 5], [6, 8, 9]], 8,)", "([[6, 1, 5], [3, 8, 9], [2, 7, 4]], 8,)", "([[1, 2], [3, 4]], 10,)", "([[1, 3], [3, 2]], 10,)"], "outputs": ["[1, 2, 1]", "[1]", "[1, 2, 1, 2]", "[1, 10, 1, 10, 1, 10, 1]", "[1, 7, 1, 7, 1]", "[1, 6, 1, 6, 1, 6, 1, 6, 1]", "[1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6]", "[1, 3, 1, 3, 1, 3, 1, 3]", "[1, 5, 1, 5, 1, 5, 1, 5]", "[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]", "[1, 3, 1, 3, 1, 3, 1, 3, 1, 3]"], "test": null} {"task_id": "DREval/62", "entry_point": "tri", "code": "\ndef tri(n):\n \"\"\"Everyone knows Fibonacci sequence, it was studied deeply by mathematicians in \n the last couple centuries. However, what people don't know is Tribonacci sequence.\n Tribonacci sequence is defined by the recurrence:\n tri(1) = 3\n tri(n) = 1 + n / 2, if n is even.\n tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.\n For example:\n tri(2) = 1 + (2 / 2) = 2\n tri(4) = 3\n tri(3) = tri(2) + tri(1) + tri(4)\n = 2 + 3 + 3 = 8 \n You are given a non-negative integer number n, you have to a return a list of the \n first n + 1 numbers of the Tribonacci sequence.\n Examples:\n tri(3) = [1, 3, 2, 8]\n \"\"\"\n if n == 0:\n return [1]\n my_tri = [1, 3]\n for i in range(2, n + 1):\n if i % 2 == 0:\n my_tri.append(i / 2 + 1)\n else:\n my_tri.append(my_tri[i - 1] + my_tri[i - 2] + (i + 3) / 2)\n return my_tri\n", "inputs": ["(3,)", "(4,)", "(5,)", "(6,)", "(7,)", "(8,)", "(9,)", "(20,)", "(0,)", "(1,)"], "outputs": ["[1, 3, 2.0, 8.0]", "[1, 3, 2.0, 8.0, 3.0]", "[1, 3, 2.0, 8.0, 3.0, 15.0]", "[1, 3, 2.0, 8.0, 3.0, 15.0, 4.0]", "[1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0]", "[1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0, 5.0]", "[1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0, 5.0, 35.0]", "[1, 3, 2.0, 8.0, 3.0, 15.0, 4.0, 24.0, 5.0, 35.0, 6.0, 48.0, 7.0, 63.0, 8.0, 80.0, 9.0, 99.0, 10.0, 120.0, 11.0]", "[1]", "[1, 3]"], "test": null} {"task_id": "DREval/63", "entry_point": "digits", "code": "\ndef digits(n):\n \"\"\"Given a positive integer n, return the product of the odd digits.\n Return 0 if all digits are even.\n For example:\n digits(1) == 1\n digits(4) == 0\n digits(235) == 15\n \"\"\"\n product = 1\n odd_count = 0\n for digit in str(n):\n int_digit = int(digit)\n if int_digit%2 == 1:\n product= product*int_digit\n odd_count+=1\n if odd_count ==0:\n return 0\n else:\n return product\n", "inputs": ["(5,)", "(54,)", "(120,)", "(5014,)", "(98765,)", "(5576543,)", "(2468,)"], "outputs": ["5", "5", "1", "5", "315", "2625", "0"], "test": null} {"task_id": "DREval/64", "entry_point": "is_nested", "code": "\ndef is_nested(string):\n '''\n Create a function that takes a string as input which contains only square brackets.\n The function should return True if and only if there is a valid subsequence of brackets \n where at least one bracket in the subsequence is nested.\n\n is_nested('[[]]') \u279e True\n is_nested('[]]]]]]][[[[[]') \u279e False\n is_nested('[][]') \u279e False\n is_nested('[]') \u279e False\n is_nested('[[][]]') \u279e True\n is_nested('[[]][[') \u279e True\n '''\n opening_bracket_index = []\n closing_bracket_index = []\n for i in range(len(string)):\n if string[i] == '[':\n opening_bracket_index.append(i)\n else:\n closing_bracket_index.append(i)\n closing_bracket_index.reverse()\n cnt = 0\n i = 0\n l = len(closing_bracket_index)\n for idx in opening_bracket_index:\n if i < l and idx < closing_bracket_index[i]:\n cnt += 1\n i += 1\n return cnt >= 2\n\n \n", "inputs": ["('[[]]',)", "('[]]]]]]][[[[[]',)", "('[][]',)", "('[]',)", "('[[[[]]]]',)", "('[]]]]]]]]]]',)", "('[][][[]]',)", "('[[]',)", "('[]]',)", "('[[]][[',)", "('[[][]]',)", "('',)", "('[[[[[[[[',)", "(']]]]]]]]',)"], "outputs": ["True", "False", "False", "False", "True", "False", "True", "False", "False", "True", "True", "False", "False", "False"], "test": null} {"task_id": "DREval/65", "entry_point": "sum_squares", "code": "\n\ndef sum_squares(lst):\n \"\"\"You are given a list of numbers.\n You need to return the sum of squared numbers in the given list,\n round each element in the list to the upper int(Ceiling) first.\n Examples:\n For lst = [1,2,3] the output should be 14\n For lst = [1,4,9] the output should be 98\n For lst = [1,3,5,7] the output should be 84\n For lst = [1.4,4.2,0] the output should be 29\n For lst = [-2.4,1,1] the output should be 6\n \n\n \"\"\"\n import math\n squared = 0\n for i in lst:\n squared += math.ceil(i)**2\n return squared\n", "inputs": ["([1, 2, 3],)", "([1.0, 2, 3],)", "([1, 3, 5, 7],)", "([1.4, 4.2, 0],)", "([-2.4, 1, 1],)", "([100, 1, 15, 2],)", "([10000, 10000],)", "([-1.4, 4.6, 6.3],)", "([-1.4, 17.9, 18.9, 19.9],)", "([0],)", "([-1],)", "([-1, 1, 0],)"], "outputs": ["14", "14", "84", "29", "6", "10230", "200000000", "75", "1086", "0", "1", "2"], "test": null} {"task_id": "DREval/66", "entry_point": "can_arrange", "code": "\ndef can_arrange(arr):\n \"\"\"Create a function which returns the largest index of an element which\n is not greater than or equal to the element immediately preceding it. If\n no such element exists then return -1. The given array will not contain\n duplicate values.\n\n Examples:\n can_arrange([1,2,4,3,5]) = 3\n can_arrange([1,2,3]) = -1\n \"\"\"\n ind=-1\n i=1\n while i float(temp_b) else b \n", "inputs": ["(1, 2,)", "(1, 2.5,)", "(2, 3,)", "(5, 6,)", "(1, '2,3',)", "('5,1', '6',)", "('1', '2',)", "('1', 1,)"], "outputs": ["2", "2.5", "3", "6", "'2,3'", "'6'", "'2'", "None"], "test": null} {"task_id": "DREval/68", "entry_point": "special_factorial", "code": "\ndef special_factorial(n):\n \"\"\"The Brazilian factorial is defined as:\n brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!\n where n > 0\n\n For example:\n >>> special_factorial(4)\n 288\n\n The function will receive an integer as input and should return the special\n factorial of this integer.\n \"\"\"\n fact_i = 1\n special_fact = 1\n for i in range(1, n+1):\n fact_i *= i\n special_fact *= fact_i\n return special_fact\n", "inputs": ["(4,)", "(5,)", "(7,)", "(1,)"], "outputs": ["288", "34560", "125411328000", "1"], "test": null} {"task_id": "DREval/69", "entry_point": "fix_spaces", "code": "\ndef fix_spaces(text):\n \"\"\"\n Given a string text, replace all spaces in it with underscores, \n and if a string has more than 2 consecutive spaces, \n then replace all consecutive spaces with - \n \n fix_spaces(\"Example\") == \"Example\"\n fix_spaces(\"Example 1\") == \"Example_1\"\n fix_spaces(\" Example 2\") == \"_Example_2\"\n fix_spaces(\" Example 3\") == \"_Example-3\"\n \"\"\"\n new_text = \"\"\n i = 0\n start, end = 0, 0\n while i < len(text):\n if text[i] == \" \":\n end += 1\n else:\n if end - start > 2:\n new_text += \"-\"+text[i]\n elif end - start > 0:\n new_text += \"_\"*(end - start)+text[i]\n else:\n new_text += text[i]\n start, end = i+1, i+1\n i+=1\n if end - start > 2:\n new_text += \"-\"\n elif end - start > 0:\n new_text += \"_\"\n return new_text\n", "inputs": ["('Example',)", "('Mudasir Hanif ',)", "('Yellow Yellow Dirty Fellow',)", "('Exa mple',)", "(' Exa 1 2 2 mple',)"], "outputs": ["'Example'", "'Mudasir_Hanif_'", "'Yellow_Yellow__Dirty__Fellow'", "'Exa-mple'", "'-Exa_1_2_2_mple'"], "test": null} {"task_id": "DREval/70", "entry_point": "file_name_check", "code": "\ndef file_name_check(file_name):\n \"\"\"Create a function which takes a string representing a file's name, and returns\n 'Yes' if the the file's name is valid, and returns 'No' otherwise.\n A file's name is considered to be valid if and only if all the following conditions \n are met:\n - There should not be more than three digits ('0'-'9') in the file's name.\n - The file's name contains exactly one dot '.'\n - The substring before the dot should not be empty, and it starts with a letter from \n the latin alphapet ('a'-'z' and 'A'-'Z').\n - The substring after the dot should be one of these: ['txt', 'exe', 'dll']\n Examples:\n file_name_check(\"example.txt\") # => 'Yes'\n file_name_check(\"1example.dll\") # => 'No' (the name should start with a latin alphapet letter)\n \"\"\"\n suf = ['txt', 'exe', 'dll']\n lst = file_name.split(sep='.')\n if len(lst) != 2:\n return 'No'\n if not lst[1] in suf:\n return 'No'\n if len(lst[0]) == 0:\n return 'No'\n if not lst[0][0].isalpha():\n return 'No'\n t = len([x for x in lst[0] if x.isdigit()])\n if t > 3:\n return 'No'\n return 'Yes'\n", "inputs": ["('example.txt',)", "('1example.dll',)", "('s1sdf3.asd',)", "('K.dll',)", "('MY16FILE3.exe',)", "('His12FILE94.exe',)", "('_Y.txt',)", "('?aREYA.exe',)", "('/this_is_valid.dll',)", "('this_is_valid.wow',)", "('this_is_valid.txt',)", "('this_is_valid.txtexe',)", "('#this2_i4s_5valid.ten',)", "('@this1_is6_valid.exe',)", "('this_is_12valid.6exe4.txt',)", "('all.exe.txt',)", "('I563_No.exe',)", "('Is3youfault.txt',)", "('no_one#knows.dll',)", "('1I563_Yes3.exe',)", "('I563_Yes3.txtt',)", "('final..txt',)", "('final132',)", "('_f4indsartal132.',)", "('.txt',)", "('s.',)"], "outputs": ["'Yes'", "'No'", "'No'", "'Yes'", "'Yes'", "'No'", "'No'", "'No'", "'No'", "'No'", "'Yes'", "'No'", "'No'", "'No'", "'No'", "'No'", "'Yes'", "'Yes'", "'Yes'", "'No'", "'No'", "'No'", "'No'", "'No'", "'No'", "'No'"], "test": null} {"task_id": "DREval/71", "entry_point": "sum_squares", "code": "\n\n\ndef sum_squares(lst):\n \"\"\"\"\n This function will take a list of integers. For all entries in the list, the function shall square the integer entry if its index is a \n multiple of 3 and will cube the integer entry if its index is a multiple of 4 and not a multiple of 3. The function will not \n change the entries in the list whose indexes are not a multiple of 3 or 4. The function shall then return the sum of all entries. \n \n Examples:\n For lst = [1,2,3] the output should be 6\n For lst = [] the output should be 0\n For lst = [-1,-5,2,-1,-5] the output should be -126\n \"\"\"\n result =[]\n for i in range(len(lst)):\n if i %3 == 0:\n result.append(lst[i]**2)\n elif i % 4 == 0 and i%3 != 0:\n result.append(lst[i]**3)\n else:\n result.append(lst[i])\n return sum(result)\n", "inputs": ["([1, 2, 3],)", "([1, 4, 9],)", "([],)", "([1, 1, 1, 1, 1, 1, 1, 1, 1],)", "([-1, -1, -1, -1, -1, -1, -1, -1, -1],)", "([0],)", "([-1, -5, 2, -1, -5],)", "([-56, -99, 1, 0, -2],)", "([-1, 0, 0, 0, 0, 0, 0, 0, -1],)", "([-16, -9, -2, 36, 36, 26, -20, 25, -40, 20, -4, 12, -26, 35, 37],)", "([-1, -3, 17, -1, -15, 13, -1, 14, -14, -12, -5, 14, -14, 6, 13, 11, 16, 16, 4, 10],)"], "outputs": ["6", "14", "0", "9", "-3", "0", "-126", "3030", "0", "-14196", "-1448"], "test": null} {"task_id": "DREval/72", "entry_point": "words_in_sentence", "code": "\ndef words_in_sentence(sentence):\n \"\"\"\n You are given a string representing a sentence,\n the sentence contains some words separated by a space,\n and you have to return a string that contains the words from the original sentence,\n whose lengths are prime numbers,\n the order of the words in the new string should be the same as the original one.\n\n Example 1:\n Input: sentence = \"This is a test\"\n Output: \"is\"\n\n Example 2:\n Input: sentence = \"lets go for swimming\"\n Output: \"go for\"\n\n Constraints:\n * 1 <= len(sentence) <= 100\n * sentence contains only letters\n \"\"\"\n new_lst = []\n for word in sentence.split():\n flg = 0\n if len(word) == 1:\n flg = 1\n for i in range(2, len(word)):\n if len(word)%i == 0:\n flg = 1\n if flg == 0 or len(word) == 2:\n new_lst.append(word)\n return \" \".join(new_lst)\n", "inputs": ["('This is a test',)", "('lets go for swimming',)", "('there is no place available here',)", "('Hi I am Hussein',)", "('go for it',)", "('here',)", "('here is',)"], "outputs": ["'is'", "'go for'", "'there is no place'", "'Hi am Hussein'", "'go for it'", "''", "'is'"], "test": null} {"task_id": "DREval/73", "entry_point": "simplify", "code": "\ndef simplify(x, n):\n \"\"\"Your task is to implement a function that will simplify the expression\n x * n. The function returns True if x * n evaluates to a whole number and False\n otherwise. Both x and n, are string representation of a fraction, and have the following format,\n / where both numerator and denominator are positive whole numbers.\n\n You can assume that x, and n are valid fractions, and do not have zero as denominator.\n\n simplify(\"1/5\", \"5/1\") = True\n simplify(\"1/6\", \"2/1\") = False\n simplify(\"7/10\", \"10/2\") = False\n \"\"\"\n a, b = x.split(\"/\")\n c, d = n.split(\"/\")\n numerator = int(a) * int(c)\n denom = int(b) * int(d)\n if (numerator/denom == int(numerator/denom)):\n return True\n return False\n", "inputs": ["('1/5', '5/1',)", "('1/6', '2/1',)", "('5/1', '3/1',)", "('7/10', '10/2',)", "('2/10', '50/10',)", "('7/2', '4/2',)", "('11/6', '6/1',)", "('2/3', '5/2',)", "('5/2', '3/5',)", "('2/4', '8/4',)", "('2/4', '4/2',)", "('1/5', '5/1',)", "('1/5', '1/5',)"], "outputs": ["True", "False", "True", "False", "True", "True", "True", "False", "False", "True", "True", "True", "False"], "test": null} {"task_id": "DREval/74", "entry_point": "order_by_points", "code": "\ndef order_by_points(nums):\n \"\"\"\n Write a function which sorts the given list of integers\n in ascending order according to the sum of their digits.\n Note: if there are several items with similar sum of their digits,\n order them based on their index in original list.\n\n For example:\n >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]\n >>> order_by_points([]) == []\n \"\"\"\n def digits_sum(n):\n neg = 1\n if n < 0: n, neg = -1 * n, -1 \n n = [int(i) for i in str(n)]\n n[0] = n[0] * neg\n return sum(n)\n return sorted(nums, key=digits_sum)\n", "inputs": ["([1, 11, -1, -11, -12],)", "([1234, 423, 463, 145, 2, 423, 423, 53, 6, 37, 3457, 3, 56, 0, 46],)", "([],)", "([1, -11, -32, 43, 54, -98, 2, -3],)", "([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],)", "([0, 6, 6, -76, -21, 23, 4],)"], "outputs": ["[-1, -11, 1, -12, 11]", "[0, 2, 3, 6, 53, 423, 423, 423, 1234, 145, 37, 46, 56, 463, 3457]", "[]", "[-3, -32, -98, -11, 1, 2, 43, 54]", "[1, 10, 2, 11, 3, 4, 5, 6, 7, 8, 9]", "[-76, -21, 0, 4, 23, 6, 6]"], "test": null} {"task_id": "DREval/75", "entry_point": "specialFilter", "code": "\ndef specialFilter(nums):\n \"\"\"Write a function that takes an array of numbers as input and returns \n the number of elements in the array that are greater than 10 and both \n first and last digits of a number are odd (1, 3, 5, 7, 9).\n For example:\n specialFilter([15, -73, 14, -15]) => 1 \n specialFilter([33, -2, -3, 45, 21, 109]) => 2\n \"\"\"\n \n count = 0\n for num in nums:\n if num > 10:\n odd_digits = (1, 3, 5, 7, 9)\n number_as_string = str(num)\n if int(number_as_string[0]) in odd_digits and int(number_as_string[-1]) in odd_digits:\n count += 1\n \n return count \n", "inputs": ["([5, -2, 1, -5],)", "([15, -73, 14, -15],)", "([33, -2, -3, 45, 21, 109],)", "([43, -12, 93, 125, 121, 109],)", "([71, -2, -33, 75, 21, 19],)", "([1],)", "([],)"], "outputs": ["0", "1", "2", "4", "3", "0", "0"], "test": null} {"task_id": "DREval/76", "entry_point": "get_max_triples", "code": "\ndef get_max_triples(n):\n \"\"\"\n You are given a positive integer n. You have to create an integer array a of length n.\n For each i (1 \u2264 i \u2264 n), the value of a[i] = i * i - i + 1.\n Return the number of triples (a[i], a[j], a[k]) of a where i < j < k, \n and a[i] + a[j] + a[k] is a multiple of 3.\n\n Example :\n Input: n = 5\n Output: 1\n Explanation: \n a = [1, 3, 7, 13, 21]\n The only valid triple is (1, 7, 13).\n \"\"\"\n A = [i*i - i + 1 for i in range(1,n+1)]\n ans = []\n for i in range(n):\n for j in range(i+1,n):\n for k in range(j+1,n):\n if (A[i]+A[j]+A[k])%3 == 0:\n ans += [(A[i],A[j],A[k])]\n return len(ans)\n", "inputs": ["(5,)", "(6,)", "(10,)"], "outputs": ["1", "4", "36"], "test": null} {"task_id": "DREval/77", "entry_point": "bf", "code": "\ndef bf(planet1, planet2):\n '''\n There are eight planets in our solar system: the closerst to the Sun \n is Mercury, the next one is Venus, then Earth, Mars, Jupiter, Saturn, \n Uranus, Neptune.\n Write a function that takes two planet names as strings planet1 and planet2. \n The function should return a tuple containing all planets whose orbits are \n located between the orbit of planet1 and the orbit of planet2, sorted by \n the proximity to the sun. \n The function should return an empty tuple if planet1 or planet2\n are not correct planet names. \n Examples\n bf(\"Jupiter\", \"Neptune\") ==> (\"Saturn\", \"Uranus\")\n bf(\"Earth\", \"Mercury\") ==> (\"Venus\")\n bf(\"Mercury\", \"Uranus\") ==> (\"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\")\n '''\n planet_names = (\"Mercury\", \"Venus\", \"Earth\", \"Mars\", \"Jupiter\", \"Saturn\", \"Uranus\", \"Neptune\")\n if planet1 not in planet_names or planet2 not in planet_names or planet1 == planet2:\n return ()\n planet1_index = planet_names.index(planet1)\n planet2_index = planet_names.index(planet2)\n if planet1_index < planet2_index:\n return (planet_names[planet1_index + 1: planet2_index])\n else:\n return (planet_names[planet2_index + 1 : planet1_index])\n", "inputs": ["('Jupiter', 'Neptune',)", "('Earth', 'Mercury',)", "('Mercury', 'Uranus',)", "('Neptune', 'Venus',)", "('Earth', 'Earth',)", "('Mars', 'Earth',)", "('Jupiter', 'Makemake',)"], "outputs": ["('Saturn', 'Uranus')", "('Venus',)", "('Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn')", "('Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus')", "()", "()", "()"], "test": null} {"task_id": "DREval/78", "entry_point": "sorted_list_sum", "code": "\ndef sorted_list_sum(lst):\n \"\"\"Write a function that accepts a list of strings as a parameter,\n deletes the strings that have odd lengths from it,\n and returns the resulted list with a sorted order,\n The list is always a list of strings and never an array of numbers,\n and it may contain duplicates.\n The order of the list should be ascending by length of each word, and you\n should return the list sorted by that rule.\n If two words have the same length, sort the list alphabetically.\n The function should return a list of strings in sorted order.\n You may assume that all words will have the same length.\n For example:\n assert list_sort([\"aa\", \"a\", \"aaa\"]) => [\"aa\"]\n assert list_sort([\"ab\", \"a\", \"aaa\", \"cd\"]) => [\"ab\", \"cd\"]\n \"\"\"\n lst.sort()\n new_lst = []\n for i in lst:\n if len(i)%2 == 0:\n new_lst.append(i)\n return sorted(new_lst, key=len)\n", "inputs": ["(['aa', 'a', 'aaa'],)", "(['school', 'AI', 'asdf', 'b'],)", "(['d', 'b', 'c', 'a'],)", "(['d', 'dcba', 'abcd', 'a'],)", "(['AI', 'ai', 'au'],)", "(['a', 'b', 'b', 'c', 'c', 'a'],)", "(['aaaa', 'bbbb', 'dd', 'cc'],)"], "outputs": ["['aa']", "['AI', 'asdf', 'school']", "[]", "['abcd', 'dcba']", "['AI', 'ai', 'au']", "[]", "['cc', 'dd', 'aaaa', 'bbbb']"], "test": null} {"task_id": "DREval/79", "entry_point": "Strongest_Extension", "code": "\ndef Strongest_Extension(class_name, extensions):\n \"\"\"You will be given the name of a class (a string) and a list of extensions.\n The extensions are to be used to load additional classes to the class. The\n strength of the extension is as follows: Let CAP be the number of the uppercase\n letters in the extension's name, and let SM be the number of lowercase letters \n in the extension's name, the strength is given by the fraction CAP - SM. \n You should find the strongest extension and return a string in this \n format: ClassName.StrongestExtensionName.\n If there are two or more extensions with the same strength, you should\n choose the one that comes first in the list.\n For example, if you are given \"Slices\" as the class and a list of the\n extensions: ['SErviNGSliCes', 'Cheese', 'StuFfed'] then you should\n return 'Slices.SErviNGSliCes' since 'SErviNGSliCes' is the strongest extension \n (its strength is -1).\n Example:\n for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'\n \"\"\"\n strong = extensions[0]\n my_val = len([x for x in extensions[0] if x.isalpha() and x.isupper()]) - len([x for x in extensions[0] if x.isalpha() and x.islower()])\n for s in extensions:\n val = len([x for x in s if x.isalpha() and x.isupper()]) - len([x for x in s if x.isalpha() and x.islower()])\n if val > my_val:\n strong = s\n my_val = val\n\n ans = class_name + \".\" + strong\n return ans\n\n", "inputs": ["('Watashi', ['tEN', 'niNE', 'eIGHt8OKe'],)", "('Boku123', ['nani', 'NazeDa', 'YEs.WeCaNe', '32145tggg'],)", "('__YESIMHERE', ['t', 'eMptY', 'nothing', 'zeR00', 'NuLl__', '123NoooneB321'],)", "('K', ['Ta', 'TAR', 't234An', 'cosSo'],)", "('__HAHA', ['Tab', '123', '781345', '-_-'],)", "('YameRore', ['HhAas', 'okIWILL123', 'WorkOut', 'Fails', '-_-'],)", "('finNNalLLly', ['Die', 'NowW', 'Wow', 'WoW'],)", "('_', ['Bb', '91245'],)", "('Sp', ['671235', 'Bb'],)"], "outputs": ["'Watashi.eIGHt8OKe'", "'Boku123.YEs.WeCaNe'", "'__YESIMHERE.NuLl__'", "'K.TAR'", "'__HAHA.123'", "'YameRore.okIWILL123'", "'finNNalLLly.WoW'", "'_.Bb'", "'Sp.671235'"], "test": null} {"task_id": "DREval/80", "entry_point": "cycpattern_check", "code": "\ndef cycpattern_check(a , b):\n \"\"\"You are given 2 words. You need to return True if the second word or any of its rotations is a substring in the first word\n cycpattern_check(\"abcd\",\"abd\") => False\n cycpattern_check(\"hello\",\"ell\") => True\n cycpattern_check(\"whassup\",\"psus\") => False\n cycpattern_check(\"abab\",\"baa\") => True\n cycpattern_check(\"efef\",\"eeff\") => False\n cycpattern_check(\"himenss\",\"simen\") => True\n\n \"\"\"\n l = len(b)\n pat = b + b\n for i in range(len(a) - l + 1):\n for j in range(l + 1):\n if a[i:i+l] == pat[j:j+l]:\n return True\n return False\n", "inputs": ["('xyzw', 'xyw',)", "('yello', 'ell',)", "('whattup', 'ptut',)", "('efef', 'fee',)", "('abab', 'aabb',)", "('winemtt', 'tinem',)"], "outputs": ["False", "True", "False", "True", "False", "True"], "test": null} {"task_id": "DREval/81", "entry_point": "even_odd_count", "code": "\ndef even_odd_count(num):\n \"\"\"Given an integer. return a tuple that has the number of even and odd digits respectively.\n\n Example:\n even_odd_count(-12) ==> (1, 1)\n even_odd_count(123) ==> (1, 2)\n \"\"\"\n even_count = 0\n odd_count = 0\n for i in str(abs(num)):\n if int(i)%2==0:\n even_count +=1\n else:\n odd_count +=1\n return (even_count, odd_count)\n", "inputs": ["(7,)", "(-78,)", "(3452,)", "(346211,)", "(-345821,)", "(-2,)", "(-45347,)", "(0,)"], "outputs": ["(0, 1)", "(1, 1)", "(2, 2)", "(3, 3)", "(3, 3)", "(1, 0)", "(2, 3)", "(1, 0)"], "test": null} {"task_id": "DREval/82", "entry_point": "int_to_mini_roman", "code": "\ndef int_to_mini_roman(number):\n \"\"\"\n Given a positive integer, obtain its roman numeral equivalent as a string,\n and return it in lowercase.\n Restrictions: 1 <= num <= 1000\n\n Examples:\n >>> int_to_mini_roman(19) == 'xix'\n >>> int_to_mini_roman(152) == 'clii'\n >>> int_to_mini_roman(426) == 'cdxxvi'\n \"\"\"\n num = [1, 4, 5, 9, 10, 40, 50, 90, \n 100, 400, 500, 900, 1000] \n sym = [\"I\", \"IV\", \"V\", \"IX\", \"X\", \"XL\", \n \"L\", \"XC\", \"C\", \"CD\", \"D\", \"CM\", \"M\"] \n i = 12\n res = ''\n while number: \n div = number // num[i] \n number %= num[i] \n while div: \n res += sym[i] \n div -= 1\n i -= 1\n return res.lower()\n", "inputs": ["(19,)", "(152,)", "(251,)", "(426,)", "(500,)", "(1,)", "(4,)", "(43,)", "(90,)", "(94,)", "(532,)", "(900,)", "(994,)", "(1000,)"], "outputs": ["'xix'", "'clii'", "'ccli'", "'cdxxvi'", "'d'", "'i'", "'iv'", "'xliii'", "'xc'", "'xciv'", "'dxxxii'", "'cm'", "'cmxciv'", "'m'"], "test": null} {"task_id": "DREval/83", "entry_point": "do_algebra", "code": "\ndef do_algebra(operator, operand):\n \"\"\"\n Given two lists operator, and operand. The first list has basic algebra operations, and \n the second list is a list of integers. Use the two given lists to build the algebric \n expression and return the evaluation of this expression.\n\n The basic algebra operations:\n Addition ( + ) \n Subtraction ( - ) \n Multiplication ( * ) \n Floor division ( // ) \n Exponentiation ( ** ) \n\n Example:\n operator['+', '*', '-']\n array = [2, 3, 4, 5]\n result = 2 + 3 * 4 - 5\n => result = 9\n\n Note:\n The length of operator list is equal to the length of operand list minus one.\n Operand is a list of of non-negative integers.\n Operator list has at least one operator, and operand list has at least two operands.\n\n \"\"\"\n expression = str(operand[0])\n for oprt, oprn in zip(operator, operand[1:]):\n expression+= oprt + str(oprn)\n return eval(expression)\n", "inputs": ["(['**', '*', '+'], [2, 3, 4, 5],)", "(['+', '*', '-'], [2, 3, 4, 5],)", "(['//', '*'], [7, 3, 4],)"], "outputs": ["37", "9", "8"], "test": null} {"task_id": "DREval/84", "entry_point": "solve", "code": "\ndef solve(s):\n \"\"\"You are given a string s.\n if s[i] is a letter, reverse its case from lower to upper or vise versa, \n otherwise keep it as it is.\n If the string contains no letters, reverse the string.\n The function should return the resulted string.\n Examples\n solve(\"1234\") = \"4321\"\n solve(\"ab\") = \"AB\"\n solve(\"#a@C\") = \"#A@c\"\n \"\"\"\n flg = 0\n idx = 0\n new_str = list(s)\n for i in s:\n if i.isalpha():\n new_str[idx] = i.swapcase()\n flg = 1\n idx += 1\n s = \"\"\n for i in new_str:\n s += i\n if flg == 0:\n return s[len(s)::-1]\n return s\n", "inputs": ["('AsDf',)", "('1234',)", "('ab',)", "('#a@C',)", "('#AsdfW^45',)", "('#6@2',)", "('#$a^D',)", "('#ccc',)"], "outputs": ["'aSdF'", "'4321'", "'AB'", "'#A@c'", "'#aSDFw^45'", "'2@6#'", "'#$A^d'", "'#CCC'"], "test": null} {"task_id": "DREval/85", "entry_point": "AreaCalculator", "code": "import math\n\n\nclass AreaCalculator:\n\n def __init__(self, radius):\n self.radius = radius\n\n def calculate_circle_area(self):\n return math.pi * self.radius ** 2\n\n def calculate_sphere_area(self):\n return 4 * math.pi * self.radius ** 2\n\n def calculate_cylinder_area(self, height):\n return 2 * math.pi * self.radius * (self.radius + height)\n\n def calculate_sector_area(self, angle):\n return self.radius ** 2 * angle / 2\n\n def calculate_annulus_area(self, inner_radius, outer_radius):\n return math.pi * (outer_radius ** 2 - inner_radius ** 2)", "inputs": ["areaCalculator = AreaCalculator(2)\nassertAlmostEqual(12.56, areaCalculator.calculate_circle_area(), delta=0.01)\n", "areaCalculator = AreaCalculator(2)\nassertAlmostEqual(50.27, areaCalculator.calculate_sphere_area(), delta=0.01)\n", "areaCalculator = AreaCalculator(2)\nassertAlmostEqual(50.27, areaCalculator.calculate_cylinder_area(2), delta=0.01)\n", "areaCalculator = AreaCalculator(1.5)\nassertAlmostEqual(3.53, areaCalculator.calculate_sector_area(math.pi), delta=0.01)\n", "areaCalculator = AreaCalculator(2)\nassertAlmostEqual(25.128, areaCalculator.calculate_annulus_area(1, 3), delta=0.01)\n", "areaCalculator = AreaCalculator(2)\nassertAlmostEqual(12.56, areaCalculator.calculate_circle_area(), delta=0.01)\nassertAlmostEqual(50.27, areaCalculator.calculate_sphere_area(), delta=0.01)\nassertAlmostEqual(50.27, areaCalculator.calculate_cylinder_area(2), delta=0.01)\nassertAlmostEqual(6.28, areaCalculator.calculate_sector_area(math.pi), delta=0.01)\nassertAlmostEqual(25.128, areaCalculator.calculate_annulus_area(1, 3), delta=0.01)\n"], "outputs": [], "test": "import unittest\n\nclass AreaCalculatorTestCalculateCircleArea(unittest.TestCase):\n def test_calculate_circle_area(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(12.56, areaCalculator.calculate_circle_area(), delta=0.01)\n def test_calculate_circle_area_2(self):\n areaCalculator = AreaCalculator(2.5)\n self.assertAlmostEqual(19.63, areaCalculator.calculate_circle_area(), delta=0.01)\n\n def test_calculate_circle_area_3(self):\n areaCalculator = AreaCalculator(2000)\n self.assertAlmostEqual(12566370.61, areaCalculator.calculate_circle_area(), delta=0.01)\n\n def test_calculate_circle_area_4(self):\n areaCalculator = AreaCalculator(0)\n self.assertAlmostEqual(0, areaCalculator.calculate_circle_area(), delta=0.01)\n\n def test_calculate_circle_area_5(self):\n areaCalculator = AreaCalculator(0.1)\n self.assertAlmostEqual(0.031, areaCalculator.calculate_circle_area(), delta=0.01)\n\n\nclass AreaCalculatorTestCalculateSphereArea(unittest.TestCase):\n def test_calculate_sphere_area(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(50.27, areaCalculator.calculate_sphere_area(), delta=0.01)\n\n def test_calculate_sphere_area_2(self):\n areaCalculator = AreaCalculator(2.5)\n self.assertAlmostEqual(19.63, areaCalculator.calculate_circle_area(), delta=0.01)\n\n def test_calculate_sphere_area_3(self):\n areaCalculator = AreaCalculator(2000)\n self.assertAlmostEqual(12566370.61, areaCalculator.calculate_circle_area(), delta=0.01)\n\n def test_calculate_sphere_area_4(self):\n areaCalculator = AreaCalculator(0)\n self.assertAlmostEqual(0, areaCalculator.calculate_circle_area(), delta=0.01)\n\n def test_calculate_sphere_area_5(self):\n areaCalculator = AreaCalculator(0.1)\n self.assertAlmostEqual(0.031, areaCalculator.calculate_circle_area(), delta=0.01)\n\n\nclass AreaCalculatorTestCalculateCylinderArea(unittest.TestCase):\n def test_calculate_cylinder_area(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(50.27, areaCalculator.calculate_cylinder_area(2), delta=0.01)\n\n def test_calculate_cylinder_area_2(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(25.13, areaCalculator.calculate_cylinder_area(0), delta=0.01)\n\n def test_calculate_cylinder_area_3(self):\n areaCalculator = AreaCalculator(0)\n self.assertAlmostEqual(0, areaCalculator.calculate_cylinder_area(2000), delta=0.01)\n\n def test_calculate_cylinder_area_4(self):\n areaCalculator = AreaCalculator(2.5)\n self.assertAlmostEqual(70.68, areaCalculator.calculate_cylinder_area(2), delta=0.01)\n\n def test_calculate_cylinder_area_5(self):\n areaCalculator = AreaCalculator(2.5)\n self.assertAlmostEqual(62.83, areaCalculator.calculate_cylinder_area(1.5), delta=0.01)\n\nclass AreaCalculatorTestCalculateSectorArea(unittest.TestCase):\n def test_calculate_sector_area(self):\n areaCalculator = AreaCalculator(1.5)\n self.assertAlmostEqual(3.53, areaCalculator.calculate_sector_area(math.pi), delta=0.01)\n\n def test_calculate_sector_area_2(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(3.14, areaCalculator.calculate_sector_area(math.pi/2), delta=0.01)\n\n def test_calculate_sector_area_3(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(0, areaCalculator.calculate_sector_area(0), delta=0.01)\n\n def test_calculate_sector_area_4(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(12.56, areaCalculator.calculate_sector_area(2*math.pi), delta=0.01)\n\n def test5_calculate_sector_area_5(self):\n areaCalculator = AreaCalculator(0)\n self.assertAlmostEqual(0, areaCalculator.calculate_sector_area(math.pi), delta=0.01)\n\nclass AreaCalculatorTestCalculateAnnulusArea(unittest.TestCase):\n def test_calculate_annulus_area(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(25.128, areaCalculator.calculate_annulus_area(1, 3), delta=0.01)\n\n def test_calculate_annulus_area_2(self):\n areaCalculator = AreaCalculator(2.5)\n self.assertAlmostEqual(0, areaCalculator.calculate_annulus_area(3, 3), delta=0.01)\n\n def test_calculate_annulus_area_3(self):\n areaCalculator = AreaCalculator(2000)\n self.assertAlmostEqual(3.14, areaCalculator.calculate_annulus_area(0, 1), delta=0.01)\n\n def test_calculate_annulus_area_4(self):\n areaCalculator = AreaCalculator(0)\n self.assertAlmostEqual(25.13, areaCalculator.calculate_annulus_area(1, 3), delta=0.01)\n\n def test_calculate_annulus_area_5(self):\n areaCalculator = AreaCalculator(2.5)\n self.assertAlmostEqual(25.13, areaCalculator.calculate_annulus_area(1, 3), delta=0.01)\n\nclass AreaCalculatorTestCalculateMain(unittest.TestCase):\n def test_main(self):\n areaCalculator = AreaCalculator(2)\n self.assertAlmostEqual(12.56, areaCalculator.calculate_circle_area(), delta=0.01)\n self.assertAlmostEqual(50.27, areaCalculator.calculate_sphere_area(), delta=0.01)\n self.assertAlmostEqual(50.27, areaCalculator.calculate_cylinder_area(2), delta=0.01)\n self.assertAlmostEqual(6.28, areaCalculator.calculate_sector_area(math.pi), delta=0.01)\n self.assertAlmostEqual(25.128, areaCalculator.calculate_annulus_area(1, 3), delta=0.01)"} {"task_id": "DREval/86", "entry_point": "ArgumentParser", "code": "class ArgumentParser:\n def __init__(self):\n self.arguments = {}\n self.required = set()\n self.types = {}\n\n def parse_arguments(self, command_string):\n args = command_string.split()[1:]\n for i in range(len(args)):\n arg = args[i]\n if arg.startswith('--'):\n key_value = arg[2:].split('=')\n if len(key_value) == 2:\n self.arguments[key_value[0]] = self._convert_type(key_value[0], key_value[1])\n else:\n self.arguments[key_value[0]] = True\n elif arg.startswith('-'):\n key = arg[1:]\n if i + 1 < len(args) and not args[i + 1].startswith('-'):\n self.arguments[key] = self._convert_type(key, args[i + 1])\n else:\n self.arguments[key] = True\n missing_args = self.required - set(self.arguments.keys())\n if missing_args:\n return False, missing_args\n\n return True, None\n\n def get_argument(self, key):\n return self.arguments.get(key)\n\n def add_argument(self, arg, required=False, arg_type=str):\n if required:\n self.required.add(arg)\n self.types[arg] = arg_type\n\n def _convert_type(self, arg, value):\n try:\n return self.types[arg](value)\n except (ValueError, KeyError):\n return value", "inputs": ["command_str = \"script --name=John --age=25\"\nself.parser.add_argument(\"name\")\nself.parser.add_argument(\"age\", arg_type=int)\nresult, missing_args = self.parser.parse_arguments(command_str)\nassertTrue(result)\nassertIsNone(missing_args)\nassertEqual(self.parser.get_argument(\"name\"), \"John\")\nassertEqual(self.parser.get_argument(\"age\"), 25)\n", "self.parser.arguments = {\"name\": \"John\"}\nresult = self.parser.get_argument(\"name\")\nassertEqual(result, \"John\")\n", "self.parser.add_argument(\"name\")\nself.parser.add_argument(\"age\", required=True, arg_type=int)\nassertEqual(self.parser.required, {\"age\"})\nassertEqual(self.parser.types, {\"name\": str, \"age\": int})\n", "self.parser.types = {\"age\": int}\nresult = self.parser._convert_type(\"age\", \"25\")\nassertEqual(result, 25)\n", "self.parser = ArgumentParser()\ncommand = \"script --arg1=21 --option1 -arg2 value -option2\"\nself.parser.add_argument('arg1', required=True, arg_type=int)\nself.parser.add_argument('arg2')\nassertEqual(self.parser.required, {'arg1'})\nassertEqual(self.parser.types, {'arg1': int, 'arg2': str})\nassertEqual(self.parser.arguments, {})\nself.parser.parse_arguments(command)\narguments = {'arg1': 21, 'option1': True, 'arg2': 'value', 'option2': True}\nassertEqual(self.parser.arguments, arguments)\n"], "outputs": [], "test": "import unittest\n\nclass ArgumentParserTestParseArguments(unittest.TestCase):\n\n def setUp(self):\n self.parser = ArgumentParser()\n\n # key value arguments\n def test_parse_arguments_1(self):\n command_str = \"script --name=John --age=25\"\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", arg_type=int)\n\n result, missing_args = self.parser.parse_arguments(command_str)\n\n self.assertTrue(result)\n self.assertIsNone(missing_args)\n self.assertEqual(self.parser.get_argument(\"name\"), \"John\")\n self.assertEqual(self.parser.get_argument(\"age\"), 25)\n\n # switches options\n def test_parse_arguments_2(self):\n command_str = \"script --verbose -d\"\n self.parser.add_argument(\"verbose\", arg_type=bool)\n self.parser.add_argument(\"d\")\n\n result, missing_args = self.parser.parse_arguments(command_str)\n\n self.assertTrue(result)\n self.assertIsNone(missing_args)\n self.assertEqual(self.parser.get_argument(\"verbose\"), True)\n self.assertEqual(self.parser.get_argument(\"d\"), True)\n\n # miss required\n def test_parse_arguments_3(self):\n command_str = \"script --name=John\"\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=True, arg_type=int)\n\n result, missing_args = self.parser.parse_arguments(command_str)\n\n self.assertFalse(result)\n self.assertEqual(missing_args, {\"age\"})\n\n def test_parse_arguments_4(self):\n command_str = \"script --name=John\"\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=False, arg_type=int)\n\n result, missing_args = self.parser.parse_arguments(command_str)\n\n self.assertTrue(result)\n self.assertEqual(missing_args, None)\n\n def test_parse_arguments_5(self):\n command_str = \"script --name=John\"\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", arg_type=int)\n\n result, missing_args = self.parser.parse_arguments(command_str)\n\n self.assertTrue(result)\n self.assertEqual(missing_args, None)\n\nclass ArgumentParserTestGetArgument(unittest.TestCase):\n\n def setUp(self):\n self.parser = ArgumentParser()\n\n # key exists\n def test_get_argument_1(self):\n self.parser.arguments = {\"name\": \"John\"}\n result = self.parser.get_argument(\"name\")\n self.assertEqual(result, \"John\")\n\n # key not exists\n def test_get_argument_2(self):\n self.parser.arguments = {\"name\": \"John\", \"age\": 25}\n result = self.parser.get_argument(\"age\")\n self.assertEqual(result, 25)\n\n def test_get_argument_3(self):\n self.parser.arguments = {\"name\": \"John\", \"age\": \"25\", \"verbose\": True}\n result = self.parser.get_argument(\"verbose\")\n self.assertEqual(result, True)\n\n def test_get_argument_4(self):\n self.parser.arguments = {\"name\": \"Amy\", \"age\": 25, \"verbose\": True, \"d\": True}\n result = self.parser.get_argument(\"d\")\n self.assertEqual(result, True)\n\n def test_get_argument_5(self):\n self.parser.arguments = {\"name\": \"John\", \"age\": 25, \"verbose\": True, \"d\": True, \"option\": \"value\"}\n result = self.parser.get_argument(\"option\")\n self.assertEqual(result, \"value\")\n\n\nclass ArgumentParserTestAddArgument(unittest.TestCase):\n\n def setUp(self):\n self.parser = ArgumentParser()\n\n def test_add_argument(self):\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=True, arg_type=int)\n\n self.assertEqual(self.parser.required, {\"age\"})\n self.assertEqual(self.parser.types, {\"name\": str, \"age\": int})\n\n def test_add_argument_2(self):\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=False, arg_type=int)\n self.parser.add_argument(\"verbose\", arg_type=bool)\n\n self.assertEqual(self.parser.required, set())\n self.assertEqual(self.parser.types, {\"name\": str, \"age\": int, \"verbose\": bool})\n\n def test_add_argument_3(self):\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=False, arg_type=int)\n self.parser.add_argument(\"verbose\", arg_type=bool)\n self.parser.add_argument(\"d\")\n\n self.assertEqual(self.parser.required, set())\n self.assertEqual(self.parser.types, {\"name\": str, \"age\": int, \"verbose\": bool, \"d\": str})\n\n def test_add_argument_4(self):\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=False, arg_type=int)\n self.parser.add_argument(\"verbose\", arg_type=bool)\n self.parser.add_argument(\"d\")\n self.parser.add_argument(\"option\")\n\n self.assertEqual(self.parser.required, set())\n self.assertEqual(self.parser.types, {\"name\": str, \"age\": int, \"verbose\": bool, \"d\": str, \"option\": str})\n\n def test_add_argument_5(self):\n self.parser.add_argument(\"name\")\n self.parser.add_argument(\"age\", required=False, arg_type=int)\n self.parser.add_argument(\"verbose\", arg_type=bool)\n self.parser.add_argument(\"d\")\n self.parser.add_argument(\"option\")\n self.parser.add_argument(\"option2\", arg_type=bool)\n\n self.assertEqual(self.parser.required, set())\n self.assertEqual(self.parser.types, {\"name\": str, \"age\": int, \"verbose\": bool, \"d\": str, \"option\": str, \"option2\": bool})\n\n\nclass ArgumentParserTestConvertType(unittest.TestCase):\n\n def setUp(self):\n self.parser = ArgumentParser()\n\n def test_convert_type_1(self):\n self.parser.types = {\"age\": int}\n result = self.parser._convert_type(\"age\", \"25\")\n self.assertEqual(result, 25)\n\n # fail\n def test_convert_type_2(self):\n self.parser.types = {\"age\": int}\n result = self.parser._convert_type(\"age\", \"twenty-five\")\n self.assertEqual(result, \"twenty-five\")\n\n def test_convert_type_3(self):\n self.parser.types = {\"age\": int}\n result = self.parser._convert_type(\"age\", \"25\")\n self.assertEqual(result, 25)\n\n def test_convert_type_4(self):\n self.parser.types = {\"age\": int, \"verbose\": bool}\n result = self.parser._convert_type(\"verbose\", \"True\")\n self.assertEqual(result, True)\n \n def test_convert_type_5(self):\n self.parser.types = {\"age\": int, \"verbose\": bool}\n result = self.parser._convert_type(\"verbose\", \"False\")\n self.assertEqual(result, True)\n\n\nclass ArgumentParserTestMain(unittest.TestCase):\n def test_main(self):\n parser = ArgumentParser()\n command = \"script --arg1=21 --option1 -arg2 value -option2\"\n\n parser.add_argument('arg1', required=True, arg_type=int)\n parser.add_argument('arg2')\n\n self.assertEqual(parser.required, {'arg1'})\n self.assertEqual(parser.types, {'arg1': int, 'arg2': str})\n self.assertEqual(parser.arguments, {})\n\n parser.parse_arguments(command)\n arguments = {'arg1': 21, 'option1': True, 'arg2': 'value', 'option2': True}\n self.assertEqual(parser.arguments, arguments)"} {"task_id": "DREval/87", "entry_point": "ArrangementCalculator", "code": "import itertools\n\n\nclass ArrangementCalculator:\n def __init__(self, datas):\n self.datas = datas\n\n @staticmethod\n def count(n, m=None):\n if m is None or n == m:\n return ArrangementCalculator.factorial(n)\n else:\n return ArrangementCalculator.factorial(n) // ArrangementCalculator.factorial(n - m)\n\n @staticmethod\n def count_all(n):\n total = 0\n for i in range(1, n + 1):\n total += ArrangementCalculator.count(n, i)\n return total\n\n def select(self, m=None):\n if m is None:\n m = len(self.datas)\n result = []\n for permutation in itertools.permutations(self.datas, m):\n result.append(list(permutation))\n return result\n\n def select_all(self):\n result = []\n for i in range(1, len(self.datas) + 1):\n result.extend(self.select(i))\n return result\n\n @staticmethod\n def factorial(n):\n result = 1\n for i in range(2, n + 1):\n result *= i\n return result", "inputs": ["res = ArrangementCalculator.count(5, 3)\nassertEqual(res, 60)\n", "res = ArrangementCalculator.count_all(4)\nassertEqual(res, 64)\n", "ac = ArrangementCalculator([1, 2, 3, 4])\nres = ac.select(2)\nexpected = [[1, 2], [1, 3], [1, 4], [2, 1], [2, 3], [2, 4], [3, 1], [3, 2], [3, 4], [4, 1], [4, 2], [4, 3]]\nassertEqual(res, expected)\n", "ac = ArrangementCalculator([1, 2, 3])\nres = ac.select_all()\nexpected = [[1], [2], [3], [1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2], [1, 2, 3], [1, 3, 2], [2, 1, 3],\n[2, 3, 1], [3, 1, 2], [3, 2, 1]]\nassertEqual(res, expected)\n", "res = ArrangementCalculator.factorial(4)\nassertEqual(res, 24)\n", "res = ArrangementCalculator.count(5, 3)\nassertEqual(res, 60)\nres = ArrangementCalculator.count_all(4)\nassertEqual(res, 64)\nac = ArrangementCalculator([1, 2, 3, 4])\nres = ac.select(2)\nexpected = [[1, 2], [1, 3], [1, 4], [2, 1], [2, 3], [2, 4], [3, 1], [3, 2], [3, 4], [4, 1], [4, 2], [4, 3]]\nassertEqual(res, expected)\nac = ArrangementCalculator([1, 2, 3])\nres = ac.select_all()\nexpected = [[1], [2], [3], [1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2], [1, 2, 3], [1, 3, 2], [2, 1, 3],\n[2, 3, 1], [3, 1, 2], [3, 2, 1]]\nassertEqual(res, expected)\nres = ArrangementCalculator.factorial(4)\nassertEqual(res, 24)\n"], "outputs": [], "test": "import unittest\n\n\nclass ArrangementCalculatorTestCount(unittest.TestCase):\n def test_count_1(self):\n res = ArrangementCalculator.count(5, 3)\n self.assertEqual(res, 60)\n\n def test_count_2(self):\n res = ArrangementCalculator.count(4, 3)\n self.assertEqual(res, 24)\n\n def test_count_3(self):\n res = ArrangementCalculator.count(6, 3)\n self.assertEqual(res, 120)\n\n def test_count_4(self):\n res = ArrangementCalculator.count(7, 3)\n self.assertEqual(res, 210)\n\n def test_count_5(self):\n res = ArrangementCalculator.count(4, 4)\n self.assertEqual(res, 24)\n\n\nclass ArrangementCalculatorTestCountAll(unittest.TestCase):\n def test_count_all_1(self):\n res = ArrangementCalculator.count_all(4)\n self.assertEqual(res, 64)\n\n def test_count_all_2(self):\n res = ArrangementCalculator.count_all(1)\n self.assertEqual(res, 1)\n\n def test_count_all_3(self):\n res = ArrangementCalculator.count_all(2)\n self.assertEqual(res, 4)\n\n def test_count_all_4(self):\n res = ArrangementCalculator.count_all(3)\n self.assertEqual(res, 15)\n\n def test_count_all_5(self):\n res = ArrangementCalculator.count_all(5)\n self.assertEqual(res, 325)\n\n\nclass ArrangementCalculatorTestSelect(unittest.TestCase):\n def test_select_1(self):\n ac = ArrangementCalculator([1, 2, 3, 4])\n res = ac.select(2)\n expected = [[1, 2], [1, 3], [1, 4], [2, 1], [2, 3], [2, 4], [3, 1], [3, 2], [3, 4], [4, 1], [4, 2], [4, 3]]\n self.assertEqual(res, expected)\n\n def test_select_2(self):\n ac = ArrangementCalculator([1, 2, 3])\n res = ac.select(2)\n expected = [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]]\n self.assertEqual(res, expected)\n\n def test_select_3(self):\n ac = ArrangementCalculator([2, 3, 4])\n res = ac.select(2)\n expected = [[2, 3], [2, 4], [3, 2], [3, 4], [4, 2], [4, 3]]\n self.assertEqual(res, expected)\n\n def test_select_4(self):\n ac = ArrangementCalculator([1, 2])\n res = ac.select(2)\n expected = [[1, 2], [2, 1]]\n self.assertEqual(res, expected)\n\n def test_select_5(self):\n ac = ArrangementCalculator([1, 2, 3, 4])\n res = ac.select(1)\n expected = [[1], [2], [3], [4]]\n self.assertEqual(res, expected)\n\n def test_select_6(self):\n ac = ArrangementCalculator([1, 2])\n res = ac.select()\n expected = [[1, 2], [2, 1]]\n self.assertEqual(res, expected)\n\n\nclass ArrangementCalculatorTestSelectAll(unittest.TestCase):\n def test_select_all_1(self):\n ac = ArrangementCalculator([1, 2, 3])\n res = ac.select_all()\n expected = [[1], [2], [3], [1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2], [1, 2, 3], [1, 3, 2], [2, 1, 3],\n [2, 3, 1], [3, 1, 2], [3, 2, 1]]\n self.assertEqual(res, expected)\n\n def test_select_all_2(self):\n ac = ArrangementCalculator([1, 2, 4])\n res = ac.select_all()\n expected = [[1], [2], [4], [1, 2], [1, 4], [2, 1], [2, 4], [4, 1], [4, 2], [1, 2, 4], [1, 4, 2], [2, 1, 4],\n [2, 4, 1], [4, 1, 2], [4, 2, 1]]\n self.assertEqual(res, expected)\n\n def test_select_all_3(self):\n ac = ArrangementCalculator([1, 2])\n res = ac.select_all()\n expected = [[1], [2], [1, 2], [2, 1]]\n self.assertEqual(res, expected)\n\n def test_select_all_4(self):\n ac = ArrangementCalculator([1, 3])\n res = ac.select_all()\n expected = [[1], [3], [1, 3], [3, 1]]\n self.assertEqual(res, expected)\n\n def test_select_all_5(self):\n ac = ArrangementCalculator([1])\n res = ac.select_all()\n expected = [[1]]\n self.assertEqual(res, expected)\n\n\nclass ArrangementCalculatorTestFactorial(unittest.TestCase):\n def test_factorial_1(self):\n res = ArrangementCalculator.factorial(4)\n self.assertEqual(res, 24)\n\n def test_factorial_2(self):\n res = ArrangementCalculator.factorial(5)\n self.assertEqual(res, 120)\n\n def test_factorial_3(self):\n res = ArrangementCalculator.factorial(3)\n self.assertEqual(res, 6)\n\n def test_factorial_4(self):\n res = ArrangementCalculator.factorial(2)\n self.assertEqual(res, 2)\n\n def test_factorial_5(self):\n res = ArrangementCalculator.factorial(1)\n self.assertEqual(res, 1)\n\n\nclass ArrangementCalculatorTest(unittest.TestCase):\n def test_arrangementcalculator(self):\n res = ArrangementCalculator.count(5, 3)\n self.assertEqual(res, 60)\n\n res = ArrangementCalculator.count_all(4)\n self.assertEqual(res, 64)\n\n ac = ArrangementCalculator([1, 2, 3, 4])\n res = ac.select(2)\n expected = [[1, 2], [1, 3], [1, 4], [2, 1], [2, 3], [2, 4], [3, 1], [3, 2], [3, 4], [4, 1], [4, 2], [4, 3]]\n self.assertEqual(res, expected)\n\n ac = ArrangementCalculator([1, 2, 3])\n res = ac.select_all()\n expected = [[1], [2], [3], [1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2], [1, 2, 3], [1, 3, 2], [2, 1, 3],\n [2, 3, 1], [3, 1, 2], [3, 2, 1]]\n self.assertEqual(res, expected)\n\n res = ArrangementCalculator.factorial(4)\n self.assertEqual(res, 24)"} {"task_id": "DREval/88", "entry_point": "AssessmentSystem", "code": "class AssessmentSystem:\n def __init__(self):\n self.students = {}\n\n def add_student(self, name, grade, major):\n self.students[name] = {'name': name, 'grade': grade, 'major': major, 'courses': {}}\n\n def add_course_score(self, name, course, score):\n if name in self.students:\n self.students[name]['courses'][course] = score\n\n def get_gpa(self, name):\n if name in self.students and self.students[name]['courses']:\n return sum(self.students[name]['courses'].values()) / len(self.students[name]['courses'])\n else:\n return None\n\n def get_all_students_with_fail_course(self):\n students = []\n for name, student in self.students.items():\n for course, score in student['courses'].items():\n if score < 60:\n students.append(name)\n break\n return students\n\n def get_course_average(self, course):\n total = 0\n count = 0\n for student in self.students.values():\n if course in student['courses']:\n score = student['courses'][course]\n if score is not None:\n total += score\n count += 1\n return total / count if count > 0 else None\n\n def get_top_student(self):\n top_student = None\n top_gpa = 0\n for name, student in self.students.items():\n gpa = self.get_gpa(name)\n if gpa is not None and gpa > top_gpa:\n top_gpa = gpa\n top_student = name\n return top_student", "inputs": ["assessment_system = AssessmentSystem()\nassessment_system.add_student(\"Alice\", 3, \"Mathematics\")\nassertEqual(assessment_system.students[\"Alice\"],\n{'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}})\n", "assessment_system = AssessmentSystem()\nassessment_system.students = {\"Alice\": {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}}\nassessment_system.add_course_score(\"Alice\", \"Math\", 90)\nassertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Math\"], 90)\n", "assessment_system = AssessmentSystem()\nassessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 80}}}\nassertEqual(assessment_system.get_gpa(\"Alice\"), 85.0)\n", "assessment_system = AssessmentSystem()\nassessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 80}},\n'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics', 'courses': {'Physics': 50}},\n'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry', 'courses': {'Chemistry': 70}},\n'David': {'name': 'David', 'grade': 1, 'major': 'Physics', 'courses': {'Physics': 60}},\n'Eve': {'name': 'Eve', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90}}}\nassertEqual(assessment_system.get_all_students_with_fail_course(), ['Bob'])\n", "assessment_system = AssessmentSystem()\nassessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 80}},\n'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics', 'courses': {'Physics': 90}},\n'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry', 'courses': {'Chemistry': 70,'Physics': 80}}\n}\nassertEqual(assessment_system.get_course_average(\"Physics\"), 85.0)\n", "assessment_system = AssessmentSystem()\nassessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n'courses': {'Mathematics': 90}},\n'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n'courses': {'Physics': 85}}\n}\nassertEqual(assessment_system.get_top_student(), \"Alice\")\n", "system = AssessmentSystem()\nsystem.add_student('student 1', 3, 'SE')\nsystem.add_student('student 2', 2, 'SE')\nassertEqual({'student 1': {'name': 'student 1', 'grade': 3, 'major': 'SE', 'courses': {}},\n'student 2': {'name': 'student 2', 'grade': 2, 'major': 'SE', 'courses': {}}},\nsystem.students)\nsystem.add_course_score('student 1', 'course 1', 86)\nsystem.add_course_score('student 2', 'course 1', 59)\nsystem.add_course_score('student 1', 'course 2', 78)\nsystem.add_course_score('student 2', 'course 2', 90)\nassertEqual(system.students['student 1']['courses']['course 1'], 86)\nassertEqual(system.students['student 1']['courses']['course 2'], 78)\nassertEqual(system.students['student 2']['courses']['course 1'], 59)\nassertEqual(system.students['student 2']['courses']['course 2'], 90)\nassertEqual(system.get_all_students_with_fail_course(), ['student 2'])\nassertEqual(system.get_course_average('course 1'), 72.5)\nassertEqual(system.get_course_average('course 2'), 84)\nassertEqual(system.get_gpa('student 1'), 82.0)\nassertEqual(system.get_gpa('student 2'), 74.5)\nassertEqual(system.get_top_student(), 'student 1')\n"], "outputs": [], "test": "import unittest\n\nclass AssessmentSystemTestAddStudent(unittest.TestCase):\n def test_add_student(self):\n assessment_system = AssessmentSystem()\n assessment_system.add_student(\"Alice\", 3, \"Mathematics\")\n self.assertEqual(assessment_system.students[\"Alice\"],\n {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}})\n\n def test_add_student_2(self):\n assessment_system = AssessmentSystem()\n assessment_system.add_student(\"Alice\", 3, \"Mathematics\")\n assessment_system.add_student(\"Bob\", 2, \"Science\")\n self.assertEqual(assessment_system.students,\n {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}},\n 'Bob': {'name': 'Bob', 'grade': 2, 'major': 'Science', 'courses': {}}})\n\n def test_add_student_3(self):\n assessment_system = AssessmentSystem()\n assessment_system.add_student(\"Alice\", 3, \"Mathematics\")\n assessment_system.add_student(\"Bob\", 2, \"Science\")\n assessment_system.add_student(\"Charlie\", 4, \"Chemistry\")\n self.assertEqual(assessment_system.students,\n {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}},\n 'Bob': {'name': 'Bob', 'grade': 2, 'major': 'Science', 'courses': {}},\n 'Charlie': {'name': 'Charlie', 'grade': 4, 'major': 'Chemistry', 'courses': {}}})\n\n def test_add_student_4(self):\n assessment_system = AssessmentSystem()\n assessment_system.add_student(\"Alice\", 3, \"Mathematics\")\n assessment_system.add_student(\"Bob\", 2, \"Science\")\n assessment_system.add_student(\"Charlie\", 4, \"Chemistry\")\n assessment_system.add_student(\"David\", 1, \"Physics\")\n self.assertEqual(assessment_system.students,\n {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}},\n 'Bob': {'name': 'Bob', 'grade': 2, 'major': 'Science', 'courses': {}},\n 'Charlie': {'name': 'Charlie', 'grade': 4, 'major': 'Chemistry', 'courses': {}},\n 'David': {'name': 'David', 'grade': 1, 'major': 'Physics', 'courses': {}}})\n\n def test_add_student_5(self):\n assessment_system = AssessmentSystem()\n assessment_system.add_student(\"Alice\", 3, \"Mathematics\")\n assessment_system.add_student(\"Bob\", 2, \"Science\")\n assessment_system.add_student(\"Charlie\", 4, \"Chemistry\")\n assessment_system.add_student(\"David\", 1, \"Physics\")\n assessment_system.add_student(\"Eve\", 3, \"Mathematics\")\n self.assertEqual(assessment_system.students,\n {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}},\n 'Bob': {'name': 'Bob', 'grade': 2, 'major': 'Science', 'courses': {}},\n 'Charlie': {'name': 'Charlie', 'grade': 4, 'major': 'Chemistry', 'courses': {}},\n 'David': {'name': 'David', 'grade': 1, 'major': 'Physics', 'courses': {}},\n 'Eve': {'name': 'Eve', 'grade': 3, 'major': 'Mathematics', 'courses': {}}})\n\nclass AssessmentSystemTestAddCourseScore(unittest.TestCase):\n def test_add_course_score(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {\"Alice\": {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}}\n assessment_system.add_course_score(\"Alice\", \"Math\", 90)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Math\"], 90)\n\n def test_add_course_score_2(self):\n assessment_system = AssessmentSystem()\n assessment_system.students[\"Alice\"] = {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}\n assessment_system.add_course_score(\"Alice\", \"Math\", 90)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Math\"], 90)\n\n def test_add_course_score_3(self):\n assessment_system = AssessmentSystem()\n assessment_system.students[\"Alice\"] = {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}\n assessment_system.add_course_score(\"Alice\", \"Math\", 90)\n assessment_system.add_course_score(\"Alice\", \"Science\", 80)\n assessment_system.add_course_score(\"Alice\", \"Math\", 95)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Math\"], 95)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Science\"], 80)\n\n def test_add_course_score_4(self):\n assessment_system = AssessmentSystem()\n assessment_system.students[\"Alice\"] = {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}\n assessment_system.add_course_score(\"Alice\", \"Math\", 90)\n assessment_system.add_course_score(\"Alice\", \"Science\", 80)\n assessment_system.add_course_score(\"Alice\", \"Math\", 95)\n assessment_system.add_course_score(\"Alice\", \"Science\", 85)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Math\"], 95)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"][\"Science\"], 85)\n\n def test_add_course_score_5(self):\n assessment_system = AssessmentSystem()\n assessment_system.students[\"Alice\"] = {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}\n assessment_system.add_course_score(\"Bob\", \"Math\", 90)\n self.assertEqual(assessment_system.students[\"Alice\"][\"courses\"], {})\n\nclass AssessmentSystemTestGetGPA(unittest.TestCase):\n def test_get_gpa_1(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 80}}}\n self.assertEqual(assessment_system.get_gpa(\"Alice\"), 85.0)\n\n\n # No such student\n def test_get_gpa_2(self):\n assessment_system = AssessmentSystem()\n self.assertEqual(assessment_system.get_gpa('Alice'), None)\n\n # student don't have any scores\n def test_get_gpa_3(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}}\n self.assertEqual(assessment_system.get_gpa('Alice'), None)\n\n def test_get_gpa_4(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90}}}\n self.assertEqual(assessment_system.get_gpa('Bob'), None)\n\n def test_get_gpa_5(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90}}}\n self.assertEqual(assessment_system.get_gpa('Alice'), 90.0)\n\n\n\nclass AssessmentSystemTestGetAllStudentsWithFailCourse(unittest.TestCase):\n def test_get_all_students_with_fail_course(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 80}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics', 'courses': {'Physics': 50}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry', 'courses': {'Chemistry': 70}},\n 'David': {'name': 'David', 'grade': 1, 'major': 'Physics', 'courses': {'Physics': 60}},\n 'Eve': {'name': 'Eve', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90}}}\n self.assertEqual(assessment_system.get_all_students_with_fail_course(), ['Bob'])\n\n def test_get_all_students_with_fail_course_2(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 80}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics', 'courses': {'Physics': 70}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry', 'courses': {'Chemistry': 70}},\n 'David': {'name': 'David', 'grade': 1, 'major': 'Physics', 'courses': {'Physics': 70}},\n 'Eve': {'name': 'Eve', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90}}}\n self.assertEqual(assessment_system.get_all_students_with_fail_course(), [])\n\n def test_get_all_students_with_fail_course_3(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {}\n self.assertEqual(assessment_system.get_all_students_with_fail_course(), [])\n\n def test_get_all_students_with_fail_course_4(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {}}}\n self.assertEqual(assessment_system.get_all_students_with_fail_course(), [])\n\n def test_get_all_students_with_fail_course_5(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 50}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics', 'courses': {'Physics': 50}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry', 'courses': {'Chemistry': 70}},\n 'David': {'name': 'David', 'grade': 1, 'major': 'Physics', 'courses': {'Physics': 70}},\n 'Eve': {'name': 'Eve', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90}}}\n self.assertEqual(assessment_system.get_all_students_with_fail_course(), ['Alice', 'Bob'])\n\nclass AssessmentSystemTestGetCourseAverage(unittest.TestCase):\n\n def test_get_course_average_1(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics', 'courses': {'Mathematics': 90, 'Science': 80}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics', 'courses': {'Physics': 90}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry', 'courses': {'Chemistry': 70,'Physics': 80}}\n }\n self.assertEqual(assessment_system.get_course_average(\"Physics\"), 85.0)\n\n def test_get_course_average_2(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': {'Mathematics': 90, 'Science': 80}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70,'Physics': None }}\n }\n self.assertEqual(assessment_system.get_course_average('Physics'), 85)\n\n def test_get_course_average_3(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': {'Mathematics': 90, 'Science': 80}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70, 'Physics': 80}}\n }\n self.assertEqual(assessment_system.get_course_average('Computer'), None)\n\n def test_get_course_average_4(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {}\n self.assertEqual(assessment_system.get_course_average('Computer'), None)\n\n def test_get_course_average_5(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': {'Mathematics': 90, 'Science': 80}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70, 'Physics': 80}}\n }\n self.assertEqual(assessment_system.get_course_average('Mathematics'), 90)\n\n\nclass AssessmentSystemTestGetTopStudent(unittest.TestCase):\n def test_get_top_student(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': {'Mathematics': 90}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}}\n }\n self.assertEqual(assessment_system.get_top_student(), \"Alice\")\n\n def test_get_top_student_2(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': { }},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70, 'Physics': 80}}\n }\n self.assertEqual(assessment_system.get_top_student(), \"Bob\")\n\n def test_get_top_student_3(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {}\n self.assertEqual(assessment_system.get_top_student(), None)\n\n def test_get_top_student_4(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': {'Mathematics': 90, 'Science': 60}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70, 'Physics': 80}}\n }\n self.assertEqual(assessment_system.get_top_student(), \"Bob\")\n\n def test_get_top_student_5(self):\n assessment_system = AssessmentSystem()\n assessment_system.students = {'Alice': {'name': 'Alice', 'grade': 3, 'major': 'Mathematics',\n 'courses': {'Mathematics': 90, 'Science': 60}},\n 'Bob': {'name': 'Bob', 'grade': 4, 'major': 'Physics',\n 'courses': {'Physics': 85}},\n 'Charlie': {'name': 'Charlie', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70, 'Physics': 80}},\n 'David': {'name': 'David', 'grade': 2, 'major': 'Chemistry',\n 'courses': {'Chemistry': 70, 'Physics': 80}}\n }\n self.assertEqual(assessment_system.get_top_student(), \"Bob\")\n\n\nclass AssessmentSystemTestMain(unittest.TestCase):\n def test_main(self):\n system = AssessmentSystem()\n system.add_student('student 1', 3, 'SE')\n system.add_student('student 2', 2, 'SE')\n self.assertEqual({'student 1': {'name': 'student 1', 'grade': 3, 'major': 'SE', 'courses': {}},\n 'student 2': {'name': 'student 2', 'grade': 2, 'major': 'SE', 'courses': {}}},\n system.students)\n system.add_course_score('student 1', 'course 1', 86)\n system.add_course_score('student 2', 'course 1', 59)\n system.add_course_score('student 1', 'course 2', 78)\n system.add_course_score('student 2', 'course 2', 90)\n\n self.assertEqual(system.students['student 1']['courses']['course 1'], 86)\n self.assertEqual(system.students['student 1']['courses']['course 2'], 78)\n self.assertEqual(system.students['student 2']['courses']['course 1'], 59)\n self.assertEqual(system.students['student 2']['courses']['course 2'], 90)\n\n self.assertEqual(system.get_all_students_with_fail_course(), ['student 2'])\n self.assertEqual(system.get_course_average('course 1'), 72.5)\n self.assertEqual(system.get_course_average('course 2'), 84)\n\n self.assertEqual(system.get_gpa('student 1'), 82.0)\n self.assertEqual(system.get_gpa('student 2'), 74.5)\n\n self.assertEqual(system.get_top_student(), 'student 1')"} {"task_id": "DREval/89", "entry_point": "AutomaticGuitarSimulator", "code": "class AutomaticGuitarSimulator:\n def __init__(self, text) -> None:\n self.play_text = text\n\n def interpret(self, display=False):\n if len(self.play_text) == 0:\n return\n else:\n play_list = []\n play_segs = self.play_text.split(\" \")\n for play_seg in play_segs:\n pos = 0\n for ele in play_seg:\n if ele.isalpha():\n pos += 1\n continue\n break\n play_chord = play_seg[0:pos]\n play_value = play_seg[pos:]\n play_list.append({'Chord': play_chord, 'Tune': play_value})\n if display:\n self.display(play_chord, play_value)\n return play_list\n\n def display(self, key, value):\n return \"Normal Guitar Playing -- Chord: %s, Play Tune: %s\" % (key, value)", "inputs": ["context = AutomaticGuitarSimulator(\"C53231323\")\nplay_list = context.interpret()\nassertEqual(play_list, [{'Chord': 'C', 'Tune': '53231323'}])\n", "context = AutomaticGuitarSimulator(\"C53231323 Em43231323\")\nplay_list = context.interpret()\nstr = context.display(play_list[0]['Chord'], play_list[0]['Tune'])\nassertEqual(str, \"Normal Guitar Playing -- Chord: C, Play Tune: 53231323\")\n", "context = AutomaticGuitarSimulator(\"C53231323\")\nplay_list = context.interpret()\nassertEqual(play_list, [{'Chord': 'C', 'Tune': '53231323'}])\ncontext = AutomaticGuitarSimulator(\"C53231323 Em43231323\")\nplay_list = context.interpret()\nstr = context.display(play_list[0]['Chord'], play_list[0]['Tune'])\nassertEqual(str, \"Normal Guitar Playing -- Chord: C, Play Tune: 53231323\")\n"], "outputs": [], "test": "import unittest\n\n\nclass AutomaticGuitarSimulatorTestInterpret(unittest.TestCase):\n def test_interpret_1(self):\n context = AutomaticGuitarSimulator(\"C53231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'C', 'Tune': '53231323'}])\n\n def test_interpret_2(self):\n context = AutomaticGuitarSimulator(\"F43231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'F', 'Tune': '43231323'}])\n\n def test_interpret_3(self):\n context = AutomaticGuitarSimulator(\"Em43231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'Em', 'Tune': '43231323'}])\n\n def test_interpret_4(self):\n context = AutomaticGuitarSimulator(\"G63231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'G', 'Tune': '63231323'}])\n\n def test_interpret_5(self):\n context = AutomaticGuitarSimulator(\"F43231323 G63231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'F', 'Tune': '43231323'}, {'Chord': 'G', 'Tune': '63231323'}])\n\n def test_interpret_6(self):\n context = AutomaticGuitarSimulator(\" \")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': '', 'Tune': ''}, {'Chord': '', 'Tune': ''}])\n\n def test_interpret_7(self):\n context = AutomaticGuitarSimulator(\"ABC43231323 DEF63231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'ABC', 'Tune': '43231323'}, {'Chord': 'DEF', 'Tune': '63231323'}])\n\n def test_interpret_8(self):\n context = AutomaticGuitarSimulator(\"C53231323\")\n play_list = context.interpret(display=True)\n self.assertEqual(play_list, [{'Chord': 'C', 'Tune': '53231323'}])\n\n def test_interpret_9(self):\n context = AutomaticGuitarSimulator(\"\")\n play_list = context.interpret()\n self.assertIsNone(play_list)\n\n\nclass AutomaticGuitarSimulatorTestDisplay(unittest.TestCase):\n def test_display_1(self):\n context = AutomaticGuitarSimulator(\"C53231323 Em43231323\")\n play_list = context.interpret()\n str = context.display(play_list[0]['Chord'], play_list[0]['Tune'])\n self.assertEqual(str, \"Normal Guitar Playing -- Chord: C, Play Tune: 53231323\")\n\n def test_display_2(self):\n context = AutomaticGuitarSimulator(\"C53231323 Em43231323\")\n play_list = context.interpret()\n str = context.display(play_list[1]['Chord'], play_list[1]['Tune'])\n self.assertEqual(str, \"Normal Guitar Playing -- Chord: Em, Play Tune: 43231323\")\n\n def test_display_3(self):\n context = AutomaticGuitarSimulator(\"F43231323 G63231323\")\n play_list = context.interpret()\n str = context.display(play_list[0]['Chord'], play_list[0]['Tune'])\n self.assertEqual(str, \"Normal Guitar Playing -- Chord: F, Play Tune: 43231323\")\n\n def test_display_4(self):\n context = AutomaticGuitarSimulator(\"F43231323 G63231323\")\n play_list = context.interpret()\n str = context.display(play_list[1]['Chord'], play_list[1]['Tune'])\n self.assertEqual(str, \"Normal Guitar Playing -- Chord: G, Play Tune: 63231323\")\n\n def test_display_5(self):\n context = AutomaticGuitarSimulator(\"\")\n str = context.display('', '')\n self.assertEqual(str, \"Normal Guitar Playing -- Chord: , Play Tune: \")\n\n\nclass AutomaticGuitarSimulatorTest(unittest.TestCase):\n def test_AutomaticGuitarSimulator(self):\n context = AutomaticGuitarSimulator(\"C53231323\")\n play_list = context.interpret()\n self.assertEqual(play_list, [{'Chord': 'C', 'Tune': '53231323'}])\n\n context = AutomaticGuitarSimulator(\"C53231323 Em43231323\")\n play_list = context.interpret()\n str = context.display(play_list[0]['Chord'], play_list[0]['Tune'])\n self.assertEqual(str, \"Normal Guitar Playing -- Chord: C, Play Tune: 53231323\")"} {"task_id": "DREval/90", "entry_point": "AvgPartition", "code": "class AvgPartition:\n def __init__(self, lst, limit):\n self.lst = lst\n self.limit = limit\n\n def setNum(self):\n size = len(self.lst) // self.limit\n remainder = len(self.lst) % self.limit\n return size, remainder\n\n \n def get(self, index):\n size, remainder = self.setNum()\n start = index * size + min(index, remainder)\n end = start + size\n if index + 1 <= remainder:\n end += 1\n return self.lst[start:end]", "inputs": ["a = AvgPartition([1, 2, 3, 4], 2)\nassertEqual(a.setNum(), (2, 0))\n", "a = AvgPartition([1, 2, 3, 4], 2)\nassertEqual(a.get(0), [1, 2])\n", "a = AvgPartition([1, 2, 3, 4], 2)\nassertEqual(a.setNum(), (2, 0))\nassertEqual(a.get(0), [1, 2])\n"], "outputs": [], "test": "import unittest\n\nclass AvgPartitionTestSetNum(unittest.TestCase):\n def test_setNum(self):\n a = AvgPartition([1, 2, 3, 4], 2)\n self.assertEqual(a.setNum(), (2, 0))\n\n def test_setNum_2(self):\n a = AvgPartition([1, 2, 3, 4, 5], 2)\n self.assertEqual(a.setNum(), (2, 1))\n\n def test_setNum_3(self):\n a = AvgPartition([1, 2, 3, 4, 5], 3)\n self.assertEqual(a.setNum(), (1, 2))\n\n def test_setNum_4(self):\n a = AvgPartition([1, 2, 3, 4, 5], 4)\n self.assertEqual(a.setNum(), (1, 1))\n\n def test_setNum_5(self):\n a = AvgPartition([1, 2, 3, 4, 5], 5)\n self.assertEqual(a.setNum(), (1, 0))\n\nclass AvgPartitionTestGet(unittest.TestCase):\n\n def test_get(self):\n a = AvgPartition([1, 2, 3, 4], 2)\n self.assertEqual(a.get(0), [1, 2])\n\n def test_get_2(self):\n a = AvgPartition([1, 2, 3, 4], 2)\n self.assertEqual(a.get(1), [3, 4])\n\n def test_get_3(self):\n a = AvgPartition([1, 2, 3, 4, 5], 2)\n self.assertEqual(a.get(0), [1, 2, 3])\n\n def test_get_4(self):\n a = AvgPartition([1, 2, 3, 4, 5], 2)\n self.assertEqual(a.get(1), [4, 5])\n\n def test_get_5(self):\n a = AvgPartition([1, 2, 3, 4, 5], 3)\n self.assertEqual(a.get(0), [1, 2])\n\nclass AvgPartitionTestMain(unittest.TestCase):\n def test_main(self):\n a = AvgPartition([1, 2, 3, 4], 2)\n self.assertEqual(a.setNum(), (2, 0))\n self.assertEqual(a.get(0), [1, 2])"} {"task_id": "DREval/91", "entry_point": "BalancedBrackets", "code": "class BalancedBrackets:\n def __init__(self, expr):\n self.stack = []\n self.left_brackets = [\"(\", \"{\", \"[\"]\n self.right_brackets = [\")\", \"}\", \"]\"]\n self.expr = expr\n\n def clear_expr(self):\n self.expr = ''.join(c for c in self.expr if (c in self.left_brackets or c in self.right_brackets))\n\n def check_balanced_brackets(self):\n self.clear_expr()\n for Brkt in self.expr:\n if Brkt in self.left_brackets:\n self.stack.append(Brkt)\n else:\n Current_Brkt = self.stack.pop()\n if Current_Brkt == \"(\":\n if Brkt != \")\":\n return False\n if Current_Brkt == \"{\":\n if Brkt != \"}\":\n return False\n if Current_Brkt == \"[\":\n if Brkt != \"]\":\n return False\n if self.stack:\n return False\n return True", "inputs": ["b = BalancedBrackets(\"a(b)c\")\nb.clear_expr()\nassertEqual(b.expr, \"()\")\n", "b = BalancedBrackets(\"a(b)c\")\nassertEqual(b.check_balanced_brackets(), True)\n", "b = BalancedBrackets(\"a(b)c\")\nb.clear_expr()\nassertEqual(b.expr, \"()\")\nassertEqual(b.check_balanced_brackets(), True)\n"], "outputs": [], "test": "import unittest\n\n\nclass BalancedBracketsTestClearExpr(unittest.TestCase):\n def test_clear_expr(self):\n b = BalancedBrackets(\"a(b)c\")\n b.clear_expr()\n self.assertEqual(b.expr, \"()\")\n\n def test_clear_expr_2(self):\n b = BalancedBrackets(\"a(b){c}\")\n b.clear_expr()\n self.assertEqual(b.expr, \"(){}\")\n\n def test_clear_expr_3(self):\n b = BalancedBrackets(\"[a](b){c}\")\n b.clear_expr()\n self.assertEqual(b.expr, \"[](){}\")\n\n def test_clear_expr_4(self):\n b = BalancedBrackets(\"[a(b){c}\")\n b.clear_expr()\n self.assertEqual(b.expr, \"[(){}\")\n\n def test_clear_expr_5(self):\n b = BalancedBrackets(\"a(b){c}]\")\n b.clear_expr()\n self.assertEqual(b.expr, \"(){}]\")\n\n\nclass BalancedBracketsTestCheckBalancedBrackets(unittest.TestCase):\n def test_check_balanced_brackets(self):\n b = BalancedBrackets(\"a(b)c\")\n self.assertEqual(b.check_balanced_brackets(), True)\n\n def test_check_balanced_brackets_2(self):\n b = BalancedBrackets(\"a(b){c}\")\n self.assertEqual(b.check_balanced_brackets(), True)\n\n def test_check_balanced_brackets_3(self):\n b = BalancedBrackets(\"[a](b){c}\")\n self.assertEqual(b.check_balanced_brackets(), True)\n\n def test_check_balanced_brackets_4(self):\n b = BalancedBrackets(\"[a(b){c}\")\n self.assertEqual(b.check_balanced_brackets(), False)\n\n def test_check_balanced_brackets_5(self):\n b = BalancedBrackets(\"a(b{c}]\")\n self.assertEqual(b.check_balanced_brackets(), False)\n\n def test_check_balanced_brackets_6(self):\n b = BalancedBrackets(\"a(b{c]]\")\n self.assertEqual(b.check_balanced_brackets(), False)\n\n def test_check_balanced_brackets_7(self):\n b = BalancedBrackets(\"[a)(b){c}\")\n self.assertEqual(b.check_balanced_brackets(), False)\n\n\nclass BalancedBracketsTestMain(unittest.TestCase):\n def test_main(self):\n b = BalancedBrackets(\"a(b)c\")\n b.clear_expr()\n self.assertEqual(b.expr, \"()\")\n self.assertEqual(b.check_balanced_brackets(), True)\n\n def test_main_2(self):\n b = BalancedBrackets(\"[a(b){c}\")\n b.clear_expr()\n self.assertEqual(b.expr, \"[(){}\")\n self.assertEqual(b.check_balanced_brackets(), False)\n\n def test_main_3(self):\n b = BalancedBrackets(\"a(b{c}]\")\n b.clear_expr()\n self.assertEqual(b.expr, \"({}]\")\n self.assertEqual(b.check_balanced_brackets(), False)"} {"task_id": "DREval/92", "entry_point": "BankAccount", "code": "class BankAccount:\n def __init__(self, balance=0):\n self.balance = balance\n\n def deposit(self, amount):\n if amount < 0:\n raise ValueError(\"Invalid amount\")\n self.balance += amount\n return self.balance\n\n def withdraw(self, amount):\n if amount < 0:\n raise ValueError(\"Invalid amount\")\n if amount > self.balance:\n raise ValueError(\"Insufficient balance.\")\n self.balance -= amount\n return self.balance\n\n def view_balance(self):\n return self.balance\n\n def transfer(self, other_account, amount):\n self.withdraw(amount)\n other_account.deposit(amount)", "inputs": ["account1 = BankAccount()\nret = account1.deposit(1000)\nassertEqual(ret, 1000)\n", "account1 = BankAccount()\naccount1.balance = 1000\nret = account1.withdraw(200)\nassertEqual(ret, 800)\n", "account1 = BankAccount()\nassertEqual(account1.view_balance(), 0)\n", "account1 = BankAccount()\naccount2 = BankAccount()\naccount1.balance = 800\naccount2.balance = 1000\naccount1.transfer(account2, 300)\nassertEqual(account1.view_balance(), 500)\nassertEqual(account2.view_balance(), 1300)\n", "account1 = BankAccount()\naccount2 = BankAccount()\naccount1.deposit(1000)\naccount1.withdraw(200)\naccount1.transfer(account2, 300)\nassertEqual(account1.view_balance(), 500)\nassertEqual(account2.view_balance(), 300)\n"], "outputs": [], "test": "import unittest\n\nclass BankAccountTestDeposit(unittest.TestCase):\n\n def test_deposit(self):\n account1 = BankAccount()\n ret = account1.deposit(1000)\n self.assertEqual(ret, 1000)\n\n def test_deposit_2(self):\n account1 = BankAccount()\n account1.deposit(1000)\n ret = account1.deposit(2000)\n self.assertEqual(ret, 3000)\n\n\n def test_deposit_3(self):\n account1 = BankAccount()\n with self.assertRaises(ValueError) as context:\n account1.deposit(-1000)\n self.assertEqual(str(context.exception), \"Invalid amount\")\n\n def test_deposit_4(self):\n account1 = BankAccount()\n ret = account1.deposit(0)\n self.assertEqual(ret, 0)\n\n def test_deposit_5(self):\n account1 = BankAccount()\n account1.deposit(1000)\n ret = account1.deposit(1000)\n self.assertEqual(ret, 2000)\n\nclass BankAccountTestWithdraw(unittest.TestCase):\n\n def test_withdraw(self):\n account1 = BankAccount()\n account1.balance = 1000\n ret = account1.withdraw(200)\n self.assertEqual(ret, 800)\n\n def test_withdraw_2(self):\n account1 = BankAccount()\n account1.balance = 500\n with self.assertRaises(ValueError) as context:\n account1.withdraw(1000)\n self.assertEqual(str(context.exception), \"Insufficient balance.\")\n\n def test_withdraw_3(self):\n account1 = BankAccount()\n with self.assertRaises(ValueError) as context:\n account1.withdraw(-1000)\n self.assertEqual(str(context.exception), \"Invalid amount\")\n\n def test_withdraw_4(self):\n account1 = BankAccount()\n account1.balance = 1000\n ret = account1.withdraw(500)\n self.assertEqual(ret, 500)\n\n def test_withdraw_5(self):\n account1 = BankAccount()\n account1.balance = 1000\n ret = account1.withdraw(1000)\n self.assertEqual(ret, 0)\n\nclass BankAccountTestViewBalance(unittest.TestCase):\n\n def test_view_balance(self):\n account1 = BankAccount()\n self.assertEqual(account1.view_balance(), 0)\n\n def test_view_balance_2(self):\n account1 = BankAccount()\n account1.balance = 1000\n self.assertEqual(account1.view_balance(), 1000)\n\n def test_view_balance_3(self):\n account1 = BankAccount()\n account1.balance = 500\n self.assertEqual(account1.view_balance(), 500)\n\n def test_view_balance_4(self):\n account1 = BankAccount()\n account1.balance = 1500\n self.assertEqual(account1.view_balance(), 1500)\n\n def test_view_balance_5(self):\n account1 = BankAccount()\n account1.balance = 2000\n self.assertEqual(account1.view_balance(), 2000)\n\nclass BankAccountTestTransfer(unittest.TestCase):\n\n def test_transfer(self):\n account1 = BankAccount()\n account2 = BankAccount()\n account1.balance = 800\n account2.balance = 1000\n account1.transfer(account2, 300)\n self.assertEqual(account1.view_balance(), 500)\n self.assertEqual(account2.view_balance(), 1300)\n\n def test_transfer_2(self):\n account1 = BankAccount()\n account2 = BankAccount()\n account1.balance = 500\n with self.assertRaises(ValueError) as context:\n account1.transfer(account2, 600)\n self.assertEqual(str(context.exception), \"Insufficient balance.\")\n\n def test_transfer_3(self):\n account1 = BankAccount()\n account2 = BankAccount()\n account1.balance = 500\n account2.balance = 1000\n with self.assertRaises(ValueError) as context:\n account1.transfer(account2, -600)\n self.assertEqual(str(context.exception), \"Invalid amount\")\n\n def test_transfer_4(self):\n account1 = BankAccount()\n account2 = BankAccount()\n account1.balance = 500\n account2.balance = 1000\n account1.transfer(account2, 500)\n self.assertEqual(account1.view_balance(), 0)\n self.assertEqual(account2.view_balance(), 1500)\n\n def test_transfer_5(self):\n account1 = BankAccount()\n account2 = BankAccount()\n account1.balance = 500\n account2.balance = 1000\n account1.transfer(account2, 200)\n self.assertEqual(account1.view_balance(), 300)\n self.assertEqual(account2.view_balance(), 1200)\n\nclass BankAccountTest(unittest.TestCase):\n\n def test_all(self):\n account1 = BankAccount()\n account2 = BankAccount()\n account1.deposit(1000)\n account1.withdraw(200)\n account1.transfer(account2, 300)\n self.assertEqual(account1.view_balance(), 500)\n self.assertEqual(account2.view_balance(), 300)\n\n def test_all2(self):\n account1 = BankAccount()\n account2 = BankAccount()\n account1.deposit(1000)\n account1.withdraw(200)\n account1.transfer(account2, 300)\n account2.withdraw(100)\n self.assertEqual(account1.view_balance(), 500)\n self.assertEqual(account2.view_balance(), 200)"} {"task_id": "DREval/93", "entry_point": "BigNumCalculator", "code": "class BigNumCalculator:\n @staticmethod\n def add(num1, num2):\n max_length = max(len(num1), len(num2))\n num1 = num1.zfill(max_length)\n num2 = num2.zfill(max_length)\n\n carry = 0\n result = []\n for i in range(max_length - 1, -1, -1):\n digit_sum = int(num1[i]) + int(num2[i]) + carry\n carry = digit_sum // 10\n digit = digit_sum % 10\n result.insert(0, str(digit))\n\n if carry > 0:\n result.insert(0, str(carry))\n\n return ''.join(result)\n\n @staticmethod\n def subtract(num1, num2):\n\n if len(num1) < len(num2):\n num1, num2 = num2, num1\n negative = True\n elif len(num1) > len(num2):\n negative = False\n else:\n if num1 < num2:\n num1, num2 = num2, num1\n negative = True\n else:\n negative = False\n\n max_length = max(len(num1), len(num2))\n num1 = num1.zfill(max_length)\n num2 = num2.zfill(max_length)\n\n borrow = 0\n result = []\n for i in range(max_length - 1, -1, -1):\n digit_diff = int(num1[i]) - int(num2[i]) - borrow\n\n if digit_diff < 0:\n digit_diff += 10\n borrow = 1\n else:\n borrow = 0\n\n result.insert(0, str(digit_diff))\n\n while len(result) > 1 and result[0] == '0':\n result.pop(0)\n\n if negative:\n result.insert(0, '-')\n\n return ''.join(result)\n\n @staticmethod\n def multiply(num1, num2):\n len1, len2 = len(num1), len(num2)\n result = [0] * (len1 + len2)\n\n for i in range(len1 - 1, -1, -1):\n for j in range(len2 - 1, -1, -1):\n mul = int(num1[i]) * int(num2[j])\n p1, p2 = i + j, i + j + 1\n total = mul + result[p2]\n\n result[p1] += total // 10\n result[p2] = total % 10\n\n start = 0\n while start < len(result) - 1 and result[start] == 0:\n start += 1\n\n return ''.join(map(str, result[start:]))", "inputs": ["bigNum = BigNumCalculator()\nassertEqual(bigNum.add(\"12345678901234567890\", \"98765432109876543210\"), \"111111111011111111100\")\n", "bigNum = BigNumCalculator()\nassertEqual(bigNum.subtract(\"12345678901234567890\", \"98765432109876543210\"), \"-86419753208641975320\")\n", "bigNum = BigNumCalculator()\nassertEqual(bigNum.multiply(\"12345678901234567890\", \"98765432109876543210\"), \"1219326311370217952237463801111263526900\")\n", "bigNum = BigNumCalculator()\nassertEqual(bigNum.add(\"12345678901234567890\", \"98765432109876543210\"), \"111111111011111111100\")\nassertEqual(bigNum.subtract(\"12345678901234567890\", \"98765432109876543210\"), \"-86419753208641975320\")\nassertEqual(bigNum.multiply(\"12345678901234567890\", \"98765432109876543210\"), \"1219326311370217952237463801111263526900\")\n"], "outputs": [], "test": "import unittest\n\nclass BigNumCalculatorTestAdd(unittest.TestCase):\n def test_add(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.add(\"12345678901234567890\", \"98765432109876543210\"), \"111111111011111111100\")\n\n def test_add_2(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.add(\"123456789012345678922\", \"98765432109876543210\"), \"222222221122222222132\")\n\n def test_add_3(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.add(\"123456789012345678934\", \"98765432109876543210\"), \"222222221122222222144\")\n\n def test_add_4(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.add(\"123456789012345678946\", \"98765432109876543210\"), \"222222221122222222156\")\n\n def test_add_5(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.add(\"123456789012345678958\", \"98765432109876543210\"), \"222222221122222222168\")\n\nclass BigNumCalculatorTestSubtract(unittest.TestCase):\n def test_subtract(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.subtract(\"12345678901234567890\", \"98765432109876543210\"), \"-86419753208641975320\")\n\n def test_subtract_2(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.subtract(\"123456789012345678922\", \"98765432109876543210\"), \"24691356902469135712\")\n\n def test_subtract_3(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.subtract(\"123456789012345678934\", \"98765432109876543\"), \"123358023580235802391\")\n\n def test_subtract_4(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.subtract(\"12345678901234567\", \"98765432109876543210\"), \"-98753086430975308643\")\n\n def test_subtract_5(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.subtract(\"923456789\", \"187654321\"), \"735802468\")\n\nclass BigNumCalculatorTestMultiply(unittest.TestCase):\n def test_multiply(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.multiply(\"12345678901234567890\", \"98765432109876543210\"), \"1219326311370217952237463801111263526900\")\n\n def test_multiply_2(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.multiply(\"123456789012345678922\", \"98765432109876543210\"), \"12193263113702179524547477517529919219620\")\n\n def test_multiply_3(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.multiply(\"123456789012345678934\", \"98765432109876543\"), \"12193263113702179499806737010255845162\")\n\n def test_multiply_4(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.multiply(\"12345678901234567\", \"98765432109876543210\"), \"1219326311370217864336229223321140070\")\n\n def test_multiply_5(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.multiply(\"923456789\", \"187654321\"), \"173290656712635269\")\n\n def test_multiply_6(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.multiply(\"000000001\", \"000000001\"), \"1\")\n\nclass BigNumCalculatorTestMain(unittest.TestCase):\n def test_main(self):\n bigNum = BigNumCalculator()\n self.assertEqual(bigNum.add(\"12345678901234567890\", \"98765432109876543210\"), \"111111111011111111100\")\n self.assertEqual(bigNum.subtract(\"12345678901234567890\", \"98765432109876543210\"), \"-86419753208641975320\")\n self.assertEqual(bigNum.multiply(\"12345678901234567890\", \"98765432109876543210\"), \"1219326311370217952237463801111263526900\")"} {"task_id": "DREval/94", "entry_point": "BinaryDataProcessor", "code": "class BinaryDataProcessor:\n def __init__(self, binary_string):\n self.binary_string = binary_string\n self.clean_non_binary_chars()\n\n def clean_non_binary_chars(self):\n self.binary_string = ''.join(filter(lambda x: x in '01', self.binary_string))\n\n def calculate_binary_info(self):\n zeroes_count = self.binary_string.count('0')\n ones_count = self.binary_string.count('1')\n total_length = len(self.binary_string)\n\n zeroes_percentage = (zeroes_count / total_length)\n ones_percentage = (ones_count / total_length)\n\n return {\n 'Zeroes': zeroes_percentage,\n 'Ones': ones_percentage,\n 'Bit length': total_length\n }\n\n def convert_to_ascii(self):\n byte_array = bytearray()\n for i in range(0, len(self.binary_string), 8):\n byte = self.binary_string[i:i+8]\n decimal = int(byte, 2)\n byte_array.append(decimal)\n\n return byte_array.decode('ascii')\n\n def convert_to_utf8(self):\n byte_array = bytearray()\n for i in range(0, len(self.binary_string), 8):\n byte = self.binary_string[i:i+8]\n decimal = int(byte, 2)\n byte_array.append(decimal)\n\n return byte_array.decode('utf-8')", "inputs": ["bdp = BinaryDataProcessor(\"01101000daf3e4r01100101011011000110110001101111\")\nassertEqual(bdp.binary_string, \"0110100001100101011011000110110001101111\")\n", "bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\nassertEqual(bdp.calculate_binary_info(), {'Zeroes': 0.475, 'Ones': 0.525, 'Bit length': 40})\n", "bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\nassertEqual(bdp.convert_to_ascii(), \"hello\")\n", "bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\nassertEqual(bdp.convert_to_utf8(), \"hello\")\n", "bdp = BinaryDataProcessor(\"01101000daf3e4r01100101011011000110110001101111\")\nassertEqual(bdp.binary_string, \"0110100001100101011011000110110001101111\")\nassertEqual(bdp.calculate_binary_info(), {'Zeroes': 0.475, 'Ones': 0.525, 'Bit length': 40})\nassertEqual(bdp.convert_to_ascii(), \"hello\")\nassertEqual(bdp.convert_to_utf8(), \"hello\")\n"], "outputs": [], "test": "import unittest\n\nclass BinaryDataProcessorTestCleanNonBinaryChars(unittest.TestCase):\n def test_clean_non_binary_chars(self):\n bdp = BinaryDataProcessor(\"01101000daf3e4r01100101011011000110110001101111\")\n self.assertEqual(bdp.binary_string, \"0110100001100101011011000110110001101111\")\n\n def test_clean_non_binary_chars_2(self):\n bdp = BinaryDataProcessor(\"01101000daf3e4r01100101011011addf0110001d1111\")\n self.assertEqual(bdp.binary_string, \"011010000110010101101101100011111\")\n\n def test_clean_non_binary_chars_3(self):\n bdp = BinaryDataProcessor(\"0sd1000daf3e4r01100101011011addf0110001d1111\")\n self.assertEqual(bdp.binary_string, \"010000110010101101101100011111\")\n\n def test_clean_non_binary_chars_4(self):\n bdp = BinaryDataProcessor(\"sdsdf\")\n self.assertEqual(bdp.binary_string, \"\")\n\n def test_clean_non_binary_chars_5(self):\n bdp = BinaryDataProcessor(\"0\")\n self.assertEqual(bdp.binary_string, \"0\")\n\nclass BinaryDataProcessorTestCalculateBinaryInfo(unittest.TestCase):\n def test_calculate_binary_info(self):\n bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\n self.assertEqual(bdp.calculate_binary_info(), {'Zeroes': 0.475, 'Ones': 0.525, 'Bit length': 40})\n\n def test_calculate_binary_info_2(self):\n bdp = BinaryDataProcessor(\"0110100001100101011010011111\")\n self.assertEqual(bdp.calculate_binary_info(), {'Bit length': 28, 'Ones': 0.5357142857142857, 'Zeroes': 0.4642857142857143})\n\n def test_calculate_binary_info_3(self):\n bdp = BinaryDataProcessor(\"01101001111100101011010011111\")\n self.assertEqual(bdp.calculate_binary_info(), {'Bit length': 29, 'Ones': 0.6206896551724138, 'Zeroes': 0.3793103448275862})\n\n def test_calculate_binary_info_4(self):\n bdp = BinaryDataProcessor(\"011010011111001\")\n self.assertEqual(bdp.calculate_binary_info(), {'Bit length': 15, 'Ones': 0.6, 'Zeroes': 0.4})\n\n def test_calculate_binary_info_5(self):\n bdp = BinaryDataProcessor(\"0110100111110010\")\n self.assertEqual(bdp.calculate_binary_info(), {'Bit length': 16, 'Ones': 0.5625, 'Zeroes': 0.4375})\n\nclass BinaryDataProcessorTestConvertToAscii(unittest.TestCase):\n def test_convert_to_ascii(self):\n bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\n self.assertEqual(bdp.convert_to_ascii(), \"hello\")\n\n def test_convert_to_ascii_2(self):\n bdp = BinaryDataProcessor(\"0110100000100101011011000110110001101111\")\n self.assertEqual(bdp.convert_to_ascii(), \"h%llo\")\n\n def test_convert_to_ascii_3(self):\n bdp = BinaryDataProcessor(\"01101000011011010110001001101111\")\n self.assertEqual(bdp.convert_to_ascii(), \"hmbo\")\n\n def test_convert_to_ascii_4(self):\n bdp = BinaryDataProcessor(\"01101000011001010110001001101111\")\n self.assertEqual(bdp.convert_to_ascii(), \"hebo\")\n\n def test_convert_to_ascii_5(self):\n bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\n self.assertEqual(bdp.convert_to_ascii(), \"hello\")\n\nclass BinaryDataProcessorTestConvertToUtf8(unittest.TestCase):\n def test_convert_to_utf8(self):\n bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101111\")\n self.assertEqual(bdp.convert_to_utf8(), \"hello\")\n\n def test_convert_to_utf8_2(self):\n bdp = BinaryDataProcessor(\"0110100001100101011011000110110001101001\")\n self.assertEqual(bdp.convert_to_utf8(), \"helli\")\n\n def test_convert_to_utf8_3(self):\n bdp = BinaryDataProcessor(\"0110000001100101011011000110110001101111\")\n self.assertEqual(bdp.convert_to_utf8(), \"`ello\")\n\n def test_convert_to_utf8_4(self):\n bdp = BinaryDataProcessor(\"0110101101100101011011000110110001101111\")\n self.assertEqual(bdp.convert_to_utf8(), \"kello\")\n\n def test_convert_to_utf8_5(self):\n bdp = BinaryDataProcessor(\"0110101101100100011011000110110001101111\")\n self.assertEqual(bdp.convert_to_utf8(), \"kdllo\")\n\nclass BinaryDataProcessorTestMain(unittest.TestCase):\n def test_main(self):\n bdp = BinaryDataProcessor(\"01101000daf3e4r01100101011011000110110001101111\")\n self.assertEqual(bdp.binary_string, \"0110100001100101011011000110110001101111\")\n self.assertEqual(bdp.calculate_binary_info(), {'Zeroes': 0.475, 'Ones': 0.525, 'Bit length': 40})\n self.assertEqual(bdp.convert_to_ascii(), \"hello\")\n self.assertEqual(bdp.convert_to_utf8(), \"hello\")"} {"task_id": "DREval/95", "entry_point": "BitStatusUtil", "code": "class BitStatusUtil:\n @staticmethod\n def add(states, stat):\n BitStatusUtil.check([states, stat])\n return states | stat\n\n @staticmethod\n def has(states, stat):\n BitStatusUtil.check([states, stat])\n return (states & stat) == stat\n\n @staticmethod\n def remove(states, stat):\n BitStatusUtil.check([states, stat])\n if BitStatusUtil.has(states, stat):\n return states ^ stat\n return states\n\n @staticmethod\n def check(args):\n for arg in args:\n if arg < 0:\n raise ValueError(f\"{arg} must be greater than or equal to 0\")\n if arg % 2 != 0:\n raise ValueError(f\"{arg} not even\")", "inputs": ["bit_status_util = BitStatusUtil()\nassertEqual(bit_status_util.add(2, 4), 6)\n", "bit_status_util = BitStatusUtil()\nassertTrue(bit_status_util.has(6, 2))\n", "bit_status_util = BitStatusUtil()\nassertEqual(bit_status_util.remove(6, 2), 4)\n", "bit_status_util = BitStatusUtil()\nbit_status_util.check([2])\n", "bit_status_util = BitStatusUtil()\nassertEqual(bit_status_util.add(2, 4), 6)\nassertTrue(bit_status_util.has(6, 2))\nassertEqual(bit_status_util.remove(6, 2), 4)\nwith assertRaises(ValueError):\n\tbit_status_util.check([2, 3, 4])\n"], "outputs": [], "test": "import unittest\n\n\nclass BitStatusUtilTestAdd(unittest.TestCase):\n def test_add(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.add(2, 4), 6)\n\n def test_add_2(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.add(2, 0), 2)\n\n def test_add_3(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.add(0, 0), 0)\n\n def test_add_4(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.add(0, 2), 2)\n\n def test_add_5(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.add(2, 2), 2)\n\n\nclass BitStatusUtilTestHas(unittest.TestCase):\n def test_has(self):\n bit_status_util = BitStatusUtil()\n self.assertTrue(bit_status_util.has(6, 2))\n\n def test_has_2(self):\n bit_status_util = BitStatusUtil()\n self.assertFalse(bit_status_util.has(8, 2))\n\n def test_has_3(self):\n bit_status_util = BitStatusUtil()\n self.assertTrue(bit_status_util.has(6, 4))\n\n def test_has_4(self):\n bit_status_util = BitStatusUtil()\n self.assertFalse(bit_status_util.has(8, 6))\n\n def test_has_5(self):\n bit_status_util = BitStatusUtil()\n self.assertTrue(bit_status_util.has(6, 6))\n\n\nclass BitStatusUtilTestRemove(unittest.TestCase):\n def test_remove(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.remove(6, 2), 4)\n\n def test_remove_2(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.remove(8, 2), 8)\n\n def test_remove_3(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.remove(6, 4), 2)\n\n def test_remove_4(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.remove(8, 6), 8)\n\n def test_remove_5(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.remove(6, 6), 0)\n\n\nclass BitStatusUtilTestCheck(unittest.TestCase):\n def test_check(self):\n bit_status_util = BitStatusUtil()\n bit_status_util.check([2])\n\n def test_check_2(self):\n bit_status_util = BitStatusUtil()\n with self.assertRaises(ValueError):\n bit_status_util.check([3])\n\n def test_check_3(self):\n bit_status_util = BitStatusUtil()\n with self.assertRaises(ValueError):\n bit_status_util.check([-1])\n\n def test_check_4(self):\n bit_status_util = BitStatusUtil()\n with self.assertRaises(ValueError):\n bit_status_util.check([2, 3, 4])\n\n def test_check_5(self):\n bit_status_util = BitStatusUtil()\n with self.assertRaises(ValueError):\n bit_status_util.check([2, 3, 4, 5])\n\n\nclass BitStatusUtilTestMain(unittest.TestCase):\n def test_main(self):\n bit_status_util = BitStatusUtil()\n self.assertEqual(bit_status_util.add(2, 4), 6)\n self.assertTrue(bit_status_util.has(6, 2))\n self.assertEqual(bit_status_util.remove(6, 2), 4)\n with self.assertRaises(ValueError):\n bit_status_util.check([2, 3, 4])"} {"task_id": "DREval/96", "entry_point": "BookManagement", "code": "class BookManagement:\n def __init__(self):\n self.inventory = {}\n\n def add_book(self, title, quantity=1):\n if title in self.inventory:\n self.inventory[title] += quantity\n else:\n self.inventory[title] = quantity\n\n def remove_book(self, title, quantity):\n if title not in self.inventory or self.inventory[title] < quantity:\n raise False\n self.inventory[title] -= quantity\n if self.inventory[title] == 0:\n del (self.inventory[title])\n\n def view_inventory(self):\n return self.inventory\n\n def view_book_quantity(self, title):\n if title not in self.inventory:\n return 0\n return self.inventory[title]", "inputs": ["bookManagement = BookManagement()\nbookManagement.add_book(\"book1\")\nassertEqual({\"book1\": 1}, bookManagement.inventory)\n", "self.bookManagement.remove_book(\"book1\", 2)\nassertEqual(self.bookManagement.inventory, {\"book2\": 1})\n", "bookManagement = BookManagement()\nbookManagement.add_book(\"book1\", 2)\nbookManagement.add_book(\"book2\")\nexpected = {\"book1\": 2, \"book2\": 1}\nassertEqual(expected, bookManagement.inventory)\n", "bookManagement = BookManagement()\nbookManagement.add_book(\"book1\", 2)\nassertEqual(2, bookManagement.view_book_quantity(\"book1\"))\n", "bookManagement = BookManagement()\nbookManagement.add_book(\"book1\", 2)\nbookManagement.add_book(\"book2\")\nassertEqual(bookManagement.view_inventory(), {\"book1\": 2, \"book2\": 1})\nbookManagement.remove_book(\"book2\", 1)\nassertEqual(bookManagement.view_inventory(), {\"book1\": 2})\nassertEqual(0, bookManagement.view_book_quantity(\"book2\"))\n"], "outputs": [], "test": "import unittest\n\n\nclass BookManagementTestAddBook(unittest.TestCase):\n def test_add_book_1(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\")\n self.assertEqual({\"book1\": 1}, bookManagement.inventory)\n\n def test_add_book_2(self):\n bookManagement = BookManagement()\n self.assertEqual({}, bookManagement.inventory)\n\n def test_add_book_3(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\")\n bookManagement.add_book(\"book1\", 2)\n self.assertEqual({\"book1\": 3}, bookManagement.inventory)\n\n def test_add_book_4(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n self.assertEqual({\"book1\": 2}, bookManagement.inventory)\n\n def test_add_book_5(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.add_book(\"book1\")\n self.assertEqual({\"book1\": 3}, bookManagement.inventory)\n\n\nclass BookManagementTestRemoveBook(unittest.TestCase):\n def setUp(self) -> None:\n self.bookManagement = BookManagement()\n self.bookManagement.add_book(\"book1\", 2)\n self.bookManagement.add_book(\"book2\")\n\n # remove all this title books\n def test_remove_book_1(self):\n self.bookManagement.remove_book(\"book1\", 2)\n self.assertEqual(self.bookManagement.inventory, {\"book2\": 1})\n\n # remove part\n def test_remove_book_2(self):\n self.bookManagement.remove_book(\"book1\", 1)\n self.assertEqual(self.bookManagement.inventory, {\"book1\": 1, \"book2\": 1})\n\n # remove the title that doesn't exist\n def test_remove_book_3(self):\n with self.assertRaises(Exception):\n self.bookManagement.remove_book(\"book3\", 1)\n\n # invalid quantity\n def test_remove_book_4(self):\n with self.assertRaises(Exception):\n self.bookManagement.remove_book(\"book2\", 2)\n\n def test_remove_book_5(self):\n with self.assertRaises(Exception):\n self.bookManagement.remove_book(\"book2\", 5)\n\n\nclass BookManagementTestViewInventory(unittest.TestCase):\n def test_view_inventory_1(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.add_book(\"book2\")\n expected = {\"book1\": 2, \"book2\": 1}\n self.assertEqual(expected, bookManagement.inventory)\n\n def test_view_inventory_2(self):\n bookManagement = BookManagement()\n expected = {}\n self.assertEqual(expected, bookManagement.inventory)\n\n def test_view_inventory_3(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.add_book(\"book2\")\n expected = {\"book1\": 2, \"book2\": 1}\n self.assertEqual(expected, bookManagement.inventory)\n\n def test_view_inventory_4(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.add_book(\"book2\")\n bookManagement.remove_book(\"book1\", 2)\n expected = {\"book2\": 1}\n self.assertEqual(expected, bookManagement.inventory)\n\n def test_view_inventory_5(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.add_book(\"book2\", 1)\n bookManagement.remove_book(\"book1\", 2)\n bookManagement.remove_book(\"book2\",1)\n expected = {}\n self.assertEqual(expected, bookManagement.inventory)\n\n\nclass BookManagementTestViewBookQuantity(unittest.TestCase):\n def test_view_book_quantity_1(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n self.assertEqual(2, bookManagement.view_book_quantity(\"book1\"))\n\n def test_view_book_quantity_2(self):\n bookManagement = BookManagement()\n self.assertEqual(0, bookManagement.view_book_quantity(\"book1\"))\n\n def test_view_book_quantity_3(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n self.assertEqual(2, bookManagement.view_book_quantity(\"book1\"))\n\n def test_view_book_quantity_4(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.remove_book(\"book1\", 2)\n self.assertEqual(0, bookManagement.view_book_quantity(\"book1\"))\n\n def test_view_book_quantity_5(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 3)\n bookManagement.remove_book(\"book1\", 2)\n self.assertEqual(1, bookManagement.view_book_quantity(\"book1\"))\n\n\nclass BookManagementTestMain(unittest.TestCase):\n def test_main(self):\n bookManagement = BookManagement()\n bookManagement.add_book(\"book1\", 2)\n bookManagement.add_book(\"book2\")\n self.assertEqual(bookManagement.view_inventory(), {\"book1\": 2, \"book2\": 1})\n\n bookManagement.remove_book(\"book2\", 1)\n self.assertEqual(bookManagement.view_inventory(), {\"book1\": 2})\n self.assertEqual(0, bookManagement.view_book_quantity(\"book2\"))"} {"task_id": "DREval/97", "entry_point": "BoyerMooreSearch", "code": "class BoyerMooreSearch:\n def __init__(self, text, pattern):\n self.text, self.pattern = text, pattern\n self.textLen, self.patLen = len(text), len(pattern)\n\n def match_in_pattern(self, char):\n for i in range(self.patLen - 1, -1, -1):\n if char == self.pattern[i]:\n return i\n return -1\n\n def mismatch_in_text(self, currentPos):\n for i in range(self.patLen - 1, -1, -1):\n if self.pattern[i] != self.text[currentPos + i]:\n return currentPos + i\n return -1\n\n def bad_character_heuristic(self):\n positions = []\n for i in range(self.textLen - self.patLen + 1):\n mismatch_index = self.mismatch_in_text(i)\n if mismatch_index == -1:\n positions.append(i)\n else:\n match_index = self.match_in_pattern(self.text[mismatch_index])\n i = (mismatch_index - match_index)\n return positions", "inputs": ["boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\nassertEqual(boyerMooreSearch.match_in_pattern(\"A\"), 0)\n", "boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\nassertEqual(boyerMooreSearch.mismatch_in_text(0), -1)\n", "boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\nassertEqual(boyerMooreSearch.bad_character_heuristic(), [0, 3])\n", "boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\nassertEqual(boyerMooreSearch.match_in_pattern(\"A\"), 0)\nassertEqual(boyerMooreSearch.mismatch_in_text(0), -1)\nassertEqual(boyerMooreSearch.bad_character_heuristic(), [0, 3])\n"], "outputs": [], "test": "import unittest\n\nclass BoyerMooreSearchTestMatchInPattern(unittest.TestCase):\n def test_match_in_pattern(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\n self.assertEqual(boyerMooreSearch.match_in_pattern(\"A\"), 0)\n\n def test_match_in_pattern_2(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABAB\")\n self.assertEqual(boyerMooreSearch.match_in_pattern(\"B\"), 3)\n\n def test_match_in_pattern_3(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABCABC\")\n self.assertEqual(boyerMooreSearch.match_in_pattern(\"C\"), 5)\n\n def test_match_in_pattern_4(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABCABC\")\n self.assertEqual(boyerMooreSearch.match_in_pattern(\"D\"), -1)\n\n def test_match_in_pattern_5(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABCABC\")\n self.assertEqual(boyerMooreSearch.match_in_pattern(\"E\"), -1)\n\n\nclass BoyerMooreSearchTestMismatchInText(unittest.TestCase):\n def test_mismatch_in_text(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\n self.assertEqual(boyerMooreSearch.mismatch_in_text(0), -1)\n\n def test_mismatch_in_text_2(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABC\")\n self.assertEqual(boyerMooreSearch.mismatch_in_text(0), 2)\n\n def test_mismatch_in_text_3(self):\n boyerMooreSearch = BoyerMooreSearch(\"AAAA\", \"ABC\")\n self.assertEqual(boyerMooreSearch.mismatch_in_text(0), 2)\n\n def test_mismatch_in_text_4(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"\")\n self.assertEqual(boyerMooreSearch.mismatch_in_text(0), -1)\n\n def test_mismatch_in_text_5(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABC\")\n self.assertEqual(boyerMooreSearch.mismatch_in_text(3), 5)\n\n\nclass BoyerMooreSearchTestBadCharacterHeuristic(unittest.TestCase):\n def test_bad_character_heuristic(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\n self.assertEqual(boyerMooreSearch.bad_character_heuristic(), [0, 3])\n\n def test_bad_character_heuristic_2(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"ABC\")\n self.assertEqual(boyerMooreSearch.bad_character_heuristic(), [])\n\n def test_bad_character_heuristic_3(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"\")\n self.assertEqual(boyerMooreSearch.bad_character_heuristic(), [0, 1, 2, 3, 4, 5, 6])\n\n def test_bad_character_heuristic_4(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABACABA\", \"ABA\")\n self.assertEqual(boyerMooreSearch.bad_character_heuristic(), [0, 4])\n\n def test_bad_character_heuristic_5(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABACABA\", \"ABAC\")\n self.assertEqual(boyerMooreSearch.bad_character_heuristic(), [0])\n\nclass BoyerMooreSearchTestMain(unittest.TestCase):\n def test_main(self):\n boyerMooreSearch = BoyerMooreSearch(\"ABAABA\", \"AB\")\n self.assertEqual(boyerMooreSearch.match_in_pattern(\"A\"), 0)\n self.assertEqual(boyerMooreSearch.mismatch_in_text(0), -1)\n self.assertEqual(boyerMooreSearch.bad_character_heuristic(), [0, 3])"} {"task_id": "DREval/98", "entry_point": "CamelCaseMap", "code": "class CamelCaseMap:\n def __init__(self):\n self._data = {}\n\n def __getitem__(self, key):\n return self._data[self._convert_key(key)]\n\n def __setitem__(self, key, value):\n self._data[self._convert_key(key)] = value\n\n def __delitem__(self, key):\n del self._data[self._convert_key(key)]\n\n def __iter__(self):\n return iter(self._data)\n\n def __len__(self):\n return len(self._data)\n\n def _convert_key(self, key):\n if isinstance(key, str):\n return self._to_camel_case(key)\n return key\n\n @staticmethod\n def _to_camel_case(key):\n parts = key.split('_')\n return parts[0] + ''.join(part.title() for part in parts[1:])", "inputs": ["camelize_map = CamelCaseMap()\ncamelize_map['first_name'] = 'John'\nassertEqual(camelize_map.__getitem__('first_name'), 'John')\n", "camelize_map = CamelCaseMap()\ncamelize_map['first_name'] = 'John'\ncamelize_map.__setitem__('first_name', 'newname')\nassertEqual(camelize_map['first_name'], 'newname')\n", "camelize_map = CamelCaseMap()\ncamelize_map['first_name'] = 'John'\ncamelize_map['last_name'] = 'Doe'\ncamelize_map.__delitem__('first_name')\nassertEqual(camelize_map['last_name'], 'Doe')\n", "camelize_map = CamelCaseMap()\ncamelize_map['first_name'] = 'John'\ncamelize_map['last_name'] = 'Doe'\ncamelize_map['age'] = 30\nlst = ['firstName', 'lastName', 'age']\niter = camelize_map.__iter__()\ni = 0\nfor key in iter:\n\tassertEqual(key, lst[i])\n\ti += 1\n", "camelize_map = CamelCaseMap()\ncamelize_map['first_name'] = 'John'\nassertEqual(camelize_map.__len__(), 1)\n", "camelize_map = CamelCaseMap()\nassertEqual(camelize_map._convert_key('aaa_bbb'), 'aaaBbb')\n", "assertEqual(CamelCaseMap._to_camel_case('aaa_bbb'), 'aaaBbb')\n", "camelize_map = CamelCaseMap()\ncamelize_map['first_name'] = 'John'\nassertEqual(camelize_map.__getitem__('first_name'), 'John')\ncamelize_map = CamelCaseMap()\ncamelize_map['first_name'] = 'John'\ncamelize_map.__setitem__('first_name', 'newname')\nassertEqual(camelize_map['first_name'], 'newname')\n"], "outputs": [], "test": "import unittest\n\n\nclass CamelCaseMapTestGetitem(unittest.TestCase):\n def test_getitem_1(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n self.assertEqual(camelize_map.__getitem__('first_name'), 'John')\n\n def test_getitem_2(self):\n camelize_map = CamelCaseMap()\n camelize_map['last_name'] = 'Doe'\n self.assertEqual(camelize_map.__getitem__('last_name'), 'Doe')\n\n def test_getitem_3(self):\n camelize_map = CamelCaseMap()\n camelize_map['age'] = 30\n self.assertEqual(camelize_map.__getitem__('age'), 30)\n\n def test_getitem_4(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n self.assertEqual(camelize_map.__getitem__('first_Name'), 'John')\n\n def test_getitem_5(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n self.assertEqual(camelize_map.__getitem__('firstName'), 'John')\n\n\nclass CamelCaseMapTestSetitem(unittest.TestCase):\n def test_setitem_1(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__setitem__('first_name', 'newname')\n self.assertEqual(camelize_map['first_name'], 'newname')\n\n def test_setitem_2(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__setitem__('first_name', 'John')\n self.assertEqual(camelize_map['first_name'], 'John')\n\n def test_setitem_3(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__setitem__('first_Name', 'newname')\n self.assertEqual(camelize_map['first_name'], 'newname')\n\n def test_setitem_4(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__setitem__('firstName', 'newname')\n self.assertEqual(camelize_map['first_name'], 'newname')\n\n def test_setitem_5(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__setitem__('first_name', '')\n self.assertEqual(camelize_map['first_name'], '')\n\n\nclass CamelCaseMapTestDelitem(unittest.TestCase):\n def test_delitem_1(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map['last_name'] = 'Doe'\n camelize_map.__delitem__('first_name')\n self.assertEqual(camelize_map['last_name'], 'Doe')\n\n def test_delitem_2(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__delitem__('first_name')\n self.assertEqual('first_name' in camelize_map, False)\n\n def test_delitem_3(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__delitem__('first_Name')\n self.assertEqual('first_name' in camelize_map, False)\n\n def test_delitem_4(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__delitem__('firstName')\n self.assertEqual('first_name' in camelize_map, False)\n\n def test_delitem_5(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = ''\n camelize_map.__delitem__('first_name')\n self.assertEqual('first_name' in camelize_map, False)\n\n\nclass CamelCaseMapTestIter(unittest.TestCase):\n def test_iter_1(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map['last_name'] = 'Doe'\n camelize_map['age'] = 30\n lst = ['firstName', 'lastName', 'age']\n iter = camelize_map.__iter__()\n i = 0\n for key in iter:\n self.assertEqual(key, lst[i])\n i += 1\n\n def test_iter_2(self):\n camelize_map = CamelCaseMap()\n camelize_map['firstname'] = 'John'\n camelize_map['lastname'] = 'Doe'\n camelize_map['age'] = 30\n lst = ['firstname', 'lastname', 'age']\n iter = camelize_map.__iter__()\n i = 0\n for key in iter:\n self.assertEqual(key, lst[i])\n i += 1\n\n def test_iter_3(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_Name'] = 'John'\n camelize_map['last_Name'] = 'Doe'\n camelize_map['age'] = 30\n lst = ['firstName', 'lastName', 'age']\n iter = camelize_map.__iter__()\n i = 0\n for key in iter:\n self.assertEqual(key, lst[i])\n i += 1\n\n def test_iter_4(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_Name'] = 'John'\n camelize_map['last_Name'] = 'Doe'\n lst = ['firstName', 'lastName']\n iter = camelize_map.__iter__()\n i = 0\n for key in iter:\n self.assertEqual(key, lst[i])\n i += 1\n\n def test_iter_5(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_Name'] = 'John'\n lst = ['firstName']\n iter = camelize_map.__iter__()\n i = 0\n for key in iter:\n self.assertEqual(key, lst[i])\n i += 1\n\n\nclass CamelCaseMapTestLen(unittest.TestCase):\n def test_len_1(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n self.assertEqual(camelize_map.__len__(), 1)\n\n def test_len_2(self):\n camelize_map = CamelCaseMap()\n camelize_map['last_name'] = 'Doe'\n self.assertEqual(camelize_map.__len__(), 1)\n\n def test_len_3(self):\n camelize_map = CamelCaseMap()\n camelize_map['age'] = 30\n self.assertEqual(camelize_map.__len__(), 1)\n\n def test_len_4(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map['last_Name'] = 'Doe'\n camelize_map['age'] = 30\n self.assertEqual(camelize_map.__len__(), 3)\n\n def test_len_5(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map.__len__(), 0)\n\n\nclass CamelCaseMapTestConvertKey(unittest.TestCase):\n def test_convert_key_1(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map._convert_key('aaa_bbb'), 'aaaBbb')\n\n def test_convert_key_2(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map._convert_key('first_name'), 'firstName')\n\n def test_convert_key_3(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map._convert_key('last_name'), 'lastName')\n\n def test_convert_key_4(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map._convert_key('ccc_ddd'), 'cccDdd')\n\n def test_convert_key_5(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map._convert_key('eee_fff'), 'eeeFff')\n\n def test_convert_key_6(self):\n camelize_map = CamelCaseMap()\n self.assertEqual(camelize_map._convert_key(1234), 1234)\n\n\nclass CamelCaseMapTestToCamelCase(unittest.TestCase):\n def test_to_camel_case_1(self):\n self.assertEqual(CamelCaseMap._to_camel_case('aaa_bbb'), 'aaaBbb')\n\n def test_to_camel_case_2(self):\n self.assertEqual(CamelCaseMap._to_camel_case('first_name'), 'firstName')\n\n def test_to_camel_case_3(self):\n self.assertEqual(CamelCaseMap._to_camel_case('last_name'), 'lastName')\n\n def test_to_camel_case_4(self):\n self.assertEqual(CamelCaseMap._to_camel_case('ccc_ddd'), 'cccDdd')\n\n def test_to_camel_case_5(self):\n self.assertEqual(CamelCaseMap._to_camel_case('eee_fff'), 'eeeFff')\n\n\nclass CamelCaseMapTest(unittest.TestCase):\n def test_CamelCaseMap(self):\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n self.assertEqual(camelize_map.__getitem__('first_name'), 'John')\n\n camelize_map = CamelCaseMap()\n camelize_map['first_name'] = 'John'\n camelize_map.__setitem__('first_name', 'newname')\n self.assertEqual(camelize_map['first_name'], 'newname')"} {"task_id": "DREval/99", "entry_point": "ChandrasekharSieve", "code": "class ChandrasekharSieve:\n def __init__(self, n):\n self.n = n\n self.primes = self.generate_primes()\n\n def generate_primes(self):\n if self.n < 2:\n return []\n\n sieve = [True] * (self.n + 1)\n sieve[0] = sieve[1] = False\n\n p = 2\n while p * p <= self.n:\n if sieve[p]:\n for i in range(p * p, self.n + 1, p):\n sieve[i] = False\n p += 1\n\n primes = []\n for i in range(2, self.n + 1):\n if sieve[i]:\n primes.append(i)\n\n return primes\n\n def get_primes(self):\n return self.primes", "inputs": ["cs = ChandrasekharSieve(20)\nres = cs.generate_primes()\nassertEqual(res, [2, 3, 5, 7, 11, 13, 17, 19])\n", "cs = ChandrasekharSieve(20)\ncs.generate_primes()\nres = cs.get_primes()\nassertEqual(res, [2, 3, 5, 7, 11, 13, 17, 19])\n", "cs = ChandrasekharSieve(20)\nres = cs.generate_primes()\nassertEqual(res, [2, 3, 5, 7, 11, 13, 17, 19])\nres = cs.get_primes()\nassertEqual(res, [2, 3, 5, 7, 11, 13, 17, 19])\n"], "outputs": [], "test": "import unittest\n\n\nclass ChandrasekharSieveTestGeneratePrimes(unittest.TestCase):\n def test_generate_primes_1(self):\n cs = ChandrasekharSieve(20)\n res = cs.generate_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13, 17, 19])\n\n def test_generate_primes_2(self):\n cs = ChandrasekharSieve(18)\n res = cs.generate_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13, 17])\n\n def test_generate_primes_3(self):\n cs = ChandrasekharSieve(15)\n res = cs.generate_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13])\n\n def test_generate_primes_4(self):\n cs = ChandrasekharSieve(10)\n res = cs.generate_primes()\n self.assertEqual(res, [2, 3, 5, 7])\n\n def test_generate_primes_5(self):\n cs = ChandrasekharSieve(1)\n res = cs.generate_primes()\n self.assertEqual(res, [])\n\n\nclass ChandrasekharSieveTestGetPrimes(unittest.TestCase):\n def test_get_primes_1(self):\n cs = ChandrasekharSieve(20)\n cs.generate_primes()\n res = cs.get_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13, 17, 19])\n\n def test_get_primes_2(self):\n cs = ChandrasekharSieve(18)\n cs.generate_primes()\n res = cs.get_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13, 17])\n\n def test_get_primes_3(self):\n cs = ChandrasekharSieve(15)\n cs.generate_primes()\n res = cs.get_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13])\n\n def test_get_primes_4(self):\n cs = ChandrasekharSieve(10)\n cs.generate_primes()\n res = cs.get_primes()\n self.assertEqual(res, [2, 3, 5, 7])\n\n def test_get_primes_5(self):\n cs = ChandrasekharSieve(1)\n res = cs.get_primes()\n self.assertEqual(res, [])\n\n\nclass ChandrasekharSieveTest(unittest.TestCase):\n def test_chandrasekharsieve(self):\n cs = ChandrasekharSieve(20)\n res = cs.generate_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13, 17, 19])\n res = cs.get_primes()\n self.assertEqual(res, [2, 3, 5, 7, 11, 13, 17, 19])"} {"task_id": "DREval/100", "entry_point": "Classroom", "code": "from datetime import datetime\n\n\nclass Classroom:\n def __init__(self, id):\n self.id = id\n self.courses = []\n\n def add_course(self, course):\n\n if course not in self.courses:\n self.courses.append(course)\n\n def remove_course(self, course):\n if course in self.courses:\n self.courses.remove(course)\n\n def is_free_at(self, check_time):\n check_time = datetime.strptime(check_time, '%H:%M')\n\n for course in self.courses:\n if datetime.strptime(course['start_time'], '%H:%M') <= check_time <= datetime.strptime(course['end_time'],\n '%H:%M'):\n return False\n return True\n\n def check_course_conflict(self, new_course):\n new_start_time = datetime.strptime(new_course['start_time'], '%H:%M')\n new_end_time = datetime.strptime(new_course['end_time'], '%H:%M')\n\n flag = True\n for course in self.courses:\n start_time = datetime.strptime(course['start_time'], '%H:%M')\n end_time = datetime.strptime(course['end_time'], '%H:%M')\n if start_time <= new_start_time and end_time >= new_start_time:\n flag = False\n if start_time <= new_end_time and end_time >= new_end_time:\n flag = False\n return flag", "inputs": ["classroom = Classroom(1)\ncourse = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\nclassroom.add_course(course)\nassertIn(course, classroom.courses)\n", "classroom = Classroom(1)\ncourse = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\nclassroom.add_course(course)\nclassroom.remove_course(course)\nassertNotIn(course, classroom.courses)\n", "classroom = Classroom(1)\ncourse = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\nclassroom.add_course(course)\ncheck_time = '11:00'\nresult = classroom.is_free_at(check_time)\nassertTrue(result)\n", "classroom = Classroom(1)\nexisting_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\nclassroom.add_course(existing_course)\nnew_course = {'name': 'SE', 'start_time': '10:30', 'end_time': '11:30'}\nresult = classroom.check_course_conflict(new_course)\nassertTrue(result)\n", "classroom = Classroom(1)\ncourse = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\nclassroom.add_course(course)\nassertIn(course, classroom.courses)\nclassroom.remove_course(course)\nassertNotIn(course, classroom.courses)\nclassroom.add_course(course)\nassertIn(course, classroom.courses)\ncheck_time = '09:30'\nresult = classroom.is_free_at(check_time)\nassertFalse(result)\nnew_course = {'name': 'SE', 'start_time': '09:30', 'end_time': '10:30'}\nresult = classroom.check_course_conflict(new_course)\nassertFalse(result)\n"], "outputs": [], "test": "import unittest\nfrom datetime import datetime\n\n\nclass ClassroomTestAddCourse(unittest.TestCase):\n def test_add_course_1(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n\n def test_add_course_2(self):\n classroom = Classroom(1)\n course = {'name': 'Chinese', 'start_time': '10:00', 'end_time': '11:00'}\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n\n def test_add_course_3(self):\n classroom = Classroom(1)\n course = {'name': 'English', 'start_time': '11:00', 'end_time': '12:00'}\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n\n def test_add_course_4(self):\n classroom = Classroom(1)\n course = {'name': 'Art', 'start_time': '14:00', 'end_time': '15:00'}\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n\n def test_add_course_5(self):\n classroom = Classroom(1)\n course = {'name': 'P.E.', 'start_time': '15:00', 'end_time': '16:00'}\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n\n def test_add_course_6(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n\n\nclass ClassroomTestRemoveCourse(unittest.TestCase):\n def test_remove_course_1(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)\n\n def test_remove_course_2(self):\n classroom = Classroom(1)\n course = {'name': 'Chinese', 'start_time': '10:00', 'end_time': '11:00'}\n classroom.add_course(course)\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)\n\n def test_remove_course_3(self):\n classroom = Classroom(1)\n course = {'name': 'English', 'start_time': '11:00', 'end_time': '12:00'}\n classroom.add_course(course)\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)\n\n def test_remove_course_4(self):\n classroom = Classroom(1)\n course = {'name': 'Art', 'start_time': '14:00', 'end_time': '15:00'}\n classroom.add_course(course)\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)\n\n def test_remove_course_5(self):\n classroom = Classroom(1)\n course = {'name': 'P.E.', 'start_time': '15:00', 'end_time': '16:00'}\n classroom.add_course(course)\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)\n\n def test_remove_course_6(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)\n\n\nclass ClassroomTestIsFreeAt(unittest.TestCase):\n def test_is_free_at_1(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n check_time = '11:00'\n result = classroom.is_free_at(check_time)\n self.assertTrue(result)\n\n def test_is_free_at_2(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n check_time = '09:30'\n result = classroom.is_free_at(check_time)\n self.assertFalse(result)\n\n def test_is_free_at_3(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n check_time = '12:00'\n result = classroom.is_free_at(check_time)\n self.assertTrue(result)\n\n def test_is_free_at_4(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n check_time = '14:00'\n result = classroom.is_free_at(check_time)\n self.assertTrue(result)\n\n def test_is_free_at_5(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n check_time = '09:40'\n result = classroom.is_free_at(check_time)\n self.assertFalse(result)\n\n\nclass ClassroomTestCheckCourseConflict(unittest.TestCase):\n def test_check_course_conflict_1(self):\n classroom = Classroom(1)\n existing_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(existing_course)\n new_course = {'name': 'SE', 'start_time': '10:30', 'end_time': '11:30'}\n result = classroom.check_course_conflict(new_course)\n self.assertTrue(result)\n\n def test_check_course_conflict_2(self):\n classroom = Classroom(1)\n existing_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(existing_course)\n new_course = {'name': 'SE', 'start_time': '09:30', 'end_time': '10:30'}\n result = classroom.check_course_conflict(new_course)\n self.assertFalse(result)\n\n # have the same boundary time\n # existing_course['end_time'] == new_course['start_time']\n def test_check_course_conflict_3(self):\n classroom = Classroom(1)\n existing_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(existing_course)\n new_course = {'name': 'SE', 'start_time': '10:00', 'end_time': '11:30'}\n result = classroom.check_course_conflict(new_course)\n self.assertFalse(result)\n\n def test_check_course_conflict_4(self):\n classroom = Classroom(1)\n existing_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(existing_course)\n new_course = {'name': 'SE', 'start_time': '09:40', 'end_time': '10:40'}\n result = classroom.check_course_conflict(new_course)\n self.assertFalse(result)\n\n def test_check_course_conflict_5(self):\n classroom = Classroom(1)\n existing_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(existing_course)\n new_course = {'name': 'SE', 'start_time': '14:30', 'end_time': '15:30'}\n result = classroom.check_course_conflict(new_course)\n self.assertTrue(result)\n\n def test_check_course_conflict_6(self):\n classroom = Classroom(1)\n existing_course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(existing_course)\n new_course = {'name': 'SE', 'start_time': '8:30', 'end_time': '9:30'}\n result = classroom.check_course_conflict(new_course)\n self.assertFalse(result)\n\n\nclass ClassroomTestMain(unittest.TestCase):\n def test_main(self):\n classroom = Classroom(1)\n course = {'name': 'math', 'start_time': '09:00', 'end_time': '10:00'}\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n\n classroom.remove_course(course)\n self.assertNotIn(course, classroom.courses)\n\n classroom.add_course(course)\n self.assertIn(course, classroom.courses)\n check_time = '09:30'\n result = classroom.is_free_at(check_time)\n self.assertFalse(result)\n\n new_course = {'name': 'SE', 'start_time': '09:30', 'end_time': '10:30'}\n result = classroom.check_course_conflict(new_course)\n self.assertFalse(result)"} {"task_id": "DREval/101", "entry_point": "ClassRegistrationSystem", "code": "class ClassRegistrationSystem:\n\n def __init__(self):\n self.students = []\n self.students_registration_classes = {}\n\n def register_student(self, student):\n if student in self.students:\n return 0\n else:\n self.students.append(student)\n return 1\n\n def register_class(self, student_name, class_name):\n if student_name in self.students_registration_classes:\n self.students_registration_classes[student_name].append(class_name)\n else:\n self.students_registration_classes[student_name] = [class_name]\n return self.students_registration_classes[student_name]\n\n def get_students_by_major(self, major):\n student_list = []\n for student in self.students:\n if student[\"major\"] == major:\n student_list.append(student[\"name\"])\n return student_list\n\n def get_all_major(self):\n major_list = []\n for student in self.students:\n if student[\"major\"] not in major_list:\n major_list.append(student[\"major\"])\n return major_list\n\n def get_most_popular_class_in_major(self, major):\n class_list = []\n for student in self.students:\n if student[\"major\"] == major:\n class_list += self.students_registration_classes[student[\"name\"]]\n most_popular_class = max(set(class_list), key=class_list.count)\n return most_popular_class", "inputs": ["student1 = {\"name\": \"John\", \"major\": \"Computer Science\"}\nassertEqual(self.registration_system.register_student(student1), 1)\n", "assertEqual(self.registration_system.register_class(student_name=\"John\", class_name=\"CS101\"), [\"CS101\"])\n", "self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n{\"name\": \"Bob\", \"major\": \"Computer Science\"}]\ncs_students = self.registration_system.get_students_by_major(\"Computer Science\")\nassertEqual(cs_students, [\"John\", \"Bob\"])\n", "self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n{\"name\": \"Bob\", \"major\": \"Computer Science\"}]\nmajors = self.registration_system.get_all_major()\nassertEqual(majors, [\"Computer Science\"])\n", "self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n{\"name\": \"Bob\", \"major\": \"Computer Science\"},\n{\"name\": \"Alice\", \"major\": \"Computer Science\"}]\nself.registration_system.students_registration_classes = {\"John\": [\"Algorithms\", \"Data Structures\"],\n\"Bob\": [\"Operating Systems\", \"Data Structures\", \"Algorithms\"],\n\"Alice\": [\"Data Structures\", \"Operating Systems\", \"Calculus\"]}\ncs_most_popular_class = self.registration_system.get_most_popular_class_in_major(\"Computer Science\")\nassertEqual(cs_most_popular_class, \"Data Structures\")\n", "student1 = {\"name\": \"John\", \"major\": \"Computer Science\"}\nstudent2 = {\"name\": \"Bob\", \"major\": \"Computer Science\"}\nstudent3 = {\"name\": \"Alice\", \"major\": \"Mathematics\"}\nstudent4 = {\"name\": \"Tom\", \"major\": \"Mathematics\"}\nself.registration_system.register_student(student1)\nself.registration_system.register_student(student2)\nself.registration_system.register_student(student3)\nself.registration_system.register_student(student4)\nself.registration_system.register_class(\"John\", \"Algorithms\")\nself.registration_system.register_class(\"John\", \"Data Structures\")\nself.registration_system.register_class(\"Bob\", \"Operating Systems\")\nself.registration_system.register_class(\"Bob\", \"Data Structures\")\nassertEqual(self.registration_system.get_students_by_major(\"Computer Science\"), [\"John\", \"Bob\"])\nassertEqual(self.registration_system.get_students_by_major(\"Mathematics\"), [\"Alice\", \"Tom\"])\nassertEqual(self.registration_system.get_all_major(), [\"Computer Science\", \"Mathematics\"])\nassertEqual(self.registration_system.get_most_popular_class_in_major(\"Computer Science\"), \"Data Structures\")\n"], "outputs": [], "test": "import unittest\n\n\nclass ClassRegistrationSystemTestRegisterStudent(unittest.TestCase):\n\n def setUp(self):\n self.registration_system = ClassRegistrationSystem()\n\n def test_register_student(self):\n student1 = {\"name\": \"John\", \"major\": \"Computer Science\"}\n self.assertEqual(self.registration_system.register_student(student1), 1)\n\n def test_register_student2(self):\n student1 = {\"name\": \"John\", \"major\": \"Computer Science\"}\n self.registration_system.register_student(student1)\n self.assertEqual(self.registration_system.register_student(student1), 0)\n\n def test_register_student3(self):\n student1 = {\"name\": \"John\", \"major\": \"Computer Science\"}\n student2 = {\"name\": \"Alice\", \"major\": \"Mathematics\"}\n self.assertEqual(self.registration_system.register_student(student1), 1)\n self.assertEqual(self.registration_system.register_student(student2), 1)\n self.assertEqual(self.registration_system.register_student(student2), 0)\n\nclass ClassRegistrationSystemTestRegisterClass(unittest.TestCase):\n\n def setUp(self):\n self.registration_system = ClassRegistrationSystem()\n\n def test_register_class(self):\n self.assertEqual(self.registration_system.register_class(student_name=\"John\", class_name=\"CS101\"), [\"CS101\"])\n\n def test_register_class2(self):\n self.registration_system.register_class(student_name=\"John\", class_name=\"CS101\")\n self.registration_system.register_class(student_name=\"John\", class_name=\"CS102\")\n self.assertEqual(self.registration_system.register_class(student_name=\"John\", class_name=\"CS103\"), [\"CS101\", \"CS102\", \"CS103\"])\n\n def test_register_class3(self):\n self.registration_system.register_class(student_name=\"John\", class_name=\"CS101\")\n self.registration_system.register_class(student_name=\"Tom\", class_name=\"CS102\")\n self.assertEqual(self.registration_system.register_class(student_name=\"John\", class_name=\"CS103\"), [\"CS101\", \"CS103\"])\n\n\nclass ClassRegistrationSystemTestGetStudent(unittest.TestCase):\n\n def setUp(self):\n self.registration_system = ClassRegistrationSystem()\n\n def test_get_students_by_major(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"}]\n\n cs_students = self.registration_system.get_students_by_major(\"Computer Science\")\n\n self.assertEqual(cs_students, [\"John\", \"Bob\"])\n\n def test_get_students_by_major2(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"}]\n\n cs_students = self.registration_system.get_students_by_major(\"Computer Science\")\n math_students = self.registration_system.get_students_by_major(\"Mathematics\")\n\n self.assertEqual(cs_students, [\"John\", \"Bob\"])\n self.assertEqual(math_students, [])\n\n def test_get_students_by_major3(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Mathematics\"}]\n\n cs_students = self.registration_system.get_students_by_major(\"Computer Science\")\n math_students = self.registration_system.get_students_by_major(\"Mathematics\")\n\n self.assertEqual(cs_students, [\"John\", \"Bob\"])\n self.assertEqual(math_students, [\"Alice\"])\n\n def test_get_students_by_major4(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Mathematics\"},\n {\"name\": \"Tom\", \"major\": \"Mathematics\"},\n {\"name\": \"Jerry\", \"major\": \"Mathematics\"}]\n\n cs_students = self.registration_system.get_students_by_major(\"Computer Science\")\n math_students = self.registration_system.get_students_by_major(\"Mathematics\")\n self.assertEqual(cs_students, [\"John\", \"Bob\"])\n self.assertEqual(math_students, [\"Alice\", \"Tom\", \"Jerry\"])\n\n\n\nclass ClassRegistrationSystemTestGetMajor(unittest.TestCase):\n\n def setUp(self):\n self.registration_system = ClassRegistrationSystem()\n\n def test_get_all_major(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"}]\n\n majors = self.registration_system.get_all_major()\n\n self.assertEqual(majors, [\"Computer Science\"])\n\n def test_get_all_major2(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Mathematics\"}]\n\n majors = self.registration_system.get_all_major()\n\n self.assertEqual(majors, [\"Computer Science\", \"Mathematics\"])\n\n def test_get_all_major3(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Mathematics\"},\n {\"name\": \"Tom\", \"major\": \"Mathematics\"},\n {\"name\": \"Jerry\", \"major\": \"Physics\"}]\n\n majors = self.registration_system.get_all_major()\n\n self.assertEqual(majors, [\"Computer Science\", \"Mathematics\", \"Physics\"])\n\nclass ClassRegistrationSystemTestPopularClass(unittest.TestCase):\n\n def setUp(self):\n self.registration_system = ClassRegistrationSystem()\n\n def test_get_most_popular_class_in_major(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Computer Science\"}]\n\n self.registration_system.students_registration_classes = {\"John\": [\"Algorithms\", \"Data Structures\"],\n \"Bob\": [\"Operating Systems\", \"Data Structures\", \"Algorithms\"],\n \"Alice\": [\"Data Structures\", \"Operating Systems\", \"Calculus\"]}\n\n cs_most_popular_class = self.registration_system.get_most_popular_class_in_major(\"Computer Science\")\n\n self.assertEqual(cs_most_popular_class, \"Data Structures\")\n\n def test_get_most_popular_class_in_major2(self):\n self.registration_system.students = [{\"name\": \"John\", \"major\": \"Computer Science\"},\n {\"name\": \"Bob\", \"major\": \"Computer Science\"},\n {\"name\": \"Alice\", \"major\": \"Computer Science\"},\n {\"name\": \"Tom\", \"major\": \"Mathematics\"},\n {\"name\": \"Jerry\", \"major\": \"Mathematics\"}]\n\n self.registration_system.students_registration_classes = {\"John\": [\"Algorithms\", \"Data Structures\"],\n \"Bob\": [\"Data Structures\", \"Algorithms\",\n \"Operating Systems\"],\n \"Alice\": [\"Data Structures\", \"Operating Systems\",\n \"Calculus\"],\n \"Tom\": [\"Calculus\", \"Linear Algebra\"],\n \"Jerry\": [\"Linear Algebra\", \"Statistics\"]}\n\n cs_most_popular_class = self.registration_system.get_most_popular_class_in_major(\"Computer Science\")\n math_most_popular_class = self.registration_system.get_most_popular_class_in_major(\"Mathematics\")\n self.assertEqual(cs_most_popular_class, \"Data Structures\")\n self.assertEqual(math_most_popular_class, \"Linear Algebra\")\n\nclass ClassRegistrationSystemTest(unittest.TestCase):\n\n def setUp(self):\n self.registration_system = ClassRegistrationSystem()\n\n def test(self):\n student1 = {\"name\": \"John\", \"major\": \"Computer Science\"}\n student2 = {\"name\": \"Bob\", \"major\": \"Computer Science\"}\n student3 = {\"name\": \"Alice\", \"major\": \"Mathematics\"}\n student4 = {\"name\": \"Tom\", \"major\": \"Mathematics\"}\n self.registration_system.register_student(student1)\n self.registration_system.register_student(student2)\n self.registration_system.register_student(student3)\n self.registration_system.register_student(student4)\n self.registration_system.register_class(\"John\", \"Algorithms\")\n self.registration_system.register_class(\"John\", \"Data Structures\")\n self.registration_system.register_class(\"Bob\", \"Operating Systems\")\n self.registration_system.register_class(\"Bob\", \"Data Structures\")\n self.assertEqual(self.registration_system.get_students_by_major(\"Computer Science\"), [\"John\", \"Bob\"])\n self.assertEqual(self.registration_system.get_students_by_major(\"Mathematics\"), [\"Alice\", \"Tom\"])\n self.assertEqual(self.registration_system.get_all_major(), [\"Computer Science\", \"Mathematics\"])\n self.assertEqual(self.registration_system.get_most_popular_class_in_major(\"Computer Science\"), \"Data Structures\")"} {"task_id": "DREval/102", "entry_point": "CombinationCalculator", "code": "import math\nfrom typing import List\n\nclass CombinationCalculator:\n def __init__(self, datas: List[str]):\n self.datas = datas\n\n @staticmethod\n def count(n: int, m: int) -> int:\n if m == 0 or n == m:\n return 1\n return math.factorial(n) // (math.factorial(n - m) * math.factorial(m))\n\n @staticmethod\n def count_all(n: int) -> int:\n if n < 0 or n > 63:\n return False\n return (1 << n) - 1 if n != 63 else float(\"inf\")\n\n def select(self, m: int) -> List[List[str]]:\n result = []\n self._select(0, [None] * m, 0, result)\n return result\n\n def select_all(self) -> List[List[str]]:\n result = []\n for i in range(1, len(self.datas) + 1):\n result.extend(self.select(i))\n return result\n\n def _select(self, dataIndex: int, resultList: List[str], resultIndex: int, result: List[List[str]]):\n resultLen = len(resultList)\n resultCount = resultIndex + 1\n if resultCount > resultLen:\n result.append(resultList.copy())\n return\n\n for i in range(dataIndex, len(self.datas) + resultCount - resultLen):\n resultList[resultIndex] = self.datas[i]\n self._select(i + 1, resultList, resultIndex + 1, result)", "inputs": ["assertEqual(CombinationCalculator.count(4, 2), 6)\n", "assertEqual(CombinationCalculator.count_all(4), 15)\n", "calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\nassertEqual(calc.count(4, 2), 6)\n", "calc = CombinationCalculator([\"A\"])\nassertEqual(calc.select_all(), [['A']])\n", "calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\nresult = []\ncalc._select(0, [None] * 2, 0, result)\nassertEqual(result, [['A', 'B'], ['A', 'C'], ['A', 'D'], ['B', 'C'], ['B', 'D'], ['C', 'D']])\n", "calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\nassertEqual(calc.count(4, 2), 6)\nassertEqual(calc.count_all(4), 15)\nassertEqual(calc.select(2), [['A', 'B'], ['A', 'C'], ['A', 'D'], ['B', 'C'], ['B', 'D'], ['C', 'D']])\nassertEqual(calc.select_all(), [['A'], ['B'], ['C'], ['D'], ['A', 'B'], ['A', 'C'], ['A', 'D'], ['B', 'C'], ['B', 'D'], ['C', 'D'], ['A', 'B', 'C'], ['A', 'B', 'D'], ['A', 'C', 'D'], ['B', 'C', 'D'], ['A', 'B', 'C', 'D']])\nresult = []\ncalc._select(0, [None] * 2, 0, result)\nassertEqual(result, [['A', 'B'], ['A', 'C'], ['A', 'D'], ['B', 'C'], ['B', 'D'], ['C', 'D']])\n"], "outputs": [], "test": "import unittest\n\nclass CombinationCalculatorTestCount(unittest.TestCase):\n def test_count(self):\n self.assertEqual(CombinationCalculator.count(4, 2), 6)\n def test_count_2(self):\n self.assertEqual(CombinationCalculator.count(5, 3), 10)\n\n def test_count_3(self):\n self.assertEqual(CombinationCalculator.count(6, 6), 1)\n\n def test_count_4(self):\n self.assertEqual(CombinationCalculator.count(6, 0), 1)\n\n def test_count_5(self):\n self.assertEqual(CombinationCalculator.count(6, 3), 20)\n\nclass CombinationCalculatorTestCountAll(unittest.TestCase):\n def test_count_all(self):\n self.assertEqual(CombinationCalculator.count_all(4), 15)\n\n def test_count_all_2(self):\n self.assertEqual(CombinationCalculator.count_all(-1), False)\n\n def test_count_all_3(self):\n self.assertEqual(CombinationCalculator.count_all(65), False)\n\n def test_count_all_4(self):\n self.assertEqual(CombinationCalculator.count_all(0), 0)\n\n def test_count_all_5(self):\n self.assertEqual(CombinationCalculator.count_all(63), float(\"inf\"))\n\nclass CombinationCalculatorTestSelect(unittest.TestCase):\n def test_select(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n self.assertEqual(calc.count(4, 2), 6)\n\n def test_select_2(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n self.assertEqual(calc.count(5, 3), 10)\n\n def test_select_3(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n self.assertEqual(calc.count(6, 6), 1)\n\n def test_select_4(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n self.assertEqual(calc.count(6, 0), 1)\n\n def test_select_5(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n self.assertEqual(calc.count(6, 3), 20)\n\nclass CombinationCalculatorTestSelectAll(unittest.TestCase):\n def test_select_all(self):\n calc = CombinationCalculator([\"A\"])\n self.assertEqual(calc.select_all(), [['A']])\n\n def test_select_all_2(self):\n calc = CombinationCalculator([\"A\", \"B\"])\n self.assertEqual(calc.select_all(), [['A'], ['B'], ['A', 'B']])\n\n def test_select_all_3(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\"])\n self.assertEqual(calc.select_all(),[['A'], ['B'], ['C'], ['A', 'B'], ['A', 'C'], ['B', 'C'], ['A', 'B', 'C']])\n\n def test_select_all_4(self):\n calc = CombinationCalculator([])\n self.assertEqual(calc.select_all(),[])\n\n def test_select_all_5(self):\n calc = CombinationCalculator([\"B\"])\n self.assertEqual(calc.select_all(),[['B']])\n\n\nclass CombinationCalculatorTestSelect2(unittest.TestCase):\n def test_select2(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n result = []\n calc._select(0, [None] * 2, 0, result)\n self.assertEqual(result, [['A', 'B'], ['A', 'C'], ['A', 'D'], ['B', 'C'], ['B', 'D'], ['C', 'D']])\n\n def test_select2_2(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n result = []\n calc._select(0, [None] * 3, 0, result)\n self.assertEqual(result, [['A', 'B', 'C'], ['A', 'B', 'D'], ['A', 'C', 'D'], ['B', 'C', 'D']])\n\n def test_select2_3(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n result = []\n calc._select(0, [None] * 1, 0, result)\n self.assertEqual(result, [['A'], ['B'], ['C'], ['D']])\n\n def test_select2_4(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n result = []\n calc._select(0, [None] * 0, 0, result)\n self.assertEqual(result, [[]])\n\n def test_select2_5(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n result = []\n calc._select(0, [None] * 4, 0, result)\n self.assertEqual(result, [['A', 'B', 'C', 'D']])\n\nclass CombinationCalculatorTestMain(unittest.TestCase):\n def test_main(self):\n calc = CombinationCalculator([\"A\", \"B\", \"C\", \"D\"])\n self.assertEqual(calc.count(4, 2), 6)\n self.assertEqual(calc.count_all(4), 15)\n self.assertEqual(calc.select(2), [['A', 'B'], ['A', 'C'], ['A', 'D'], ['B', 'C'], ['B', 'D'], ['C', 'D']])\n self.assertEqual(calc.select_all(), [['A'], ['B'], ['C'], ['D'], ['A', 'B'], ['A', 'C'], ['A', 'D'], ['B', 'C'], ['B', 'D'], ['C', 'D'], ['A', 'B', 'C'], ['A', 'B', 'D'], ['A', 'C', 'D'], ['B', 'C', 'D'], ['A', 'B', 'C', 'D']])\n result = []\n calc._select(0, [None] * 2, 0, result)\n self.assertEqual(result, [['A', 'B'], ['A', 'C'], ['A', 'D'], ['B', 'C'], ['B', 'D'], ['C', 'D']])"} {"task_id": "DREval/103", "entry_point": "ComplexCalculator", "code": "class ComplexCalculator:\n def __init__(self):\n pass\n\n @staticmethod\n def add(c1, c2):\n real = c1.real + c2.real\n imaginary = c1.imag + c2.imag\n answer = complex(real, imaginary)\n return answer\n \n @staticmethod\n def subtract(c1, c2):\n real = c1.real - c2.real\n imaginary = c1.imag - c2.imag\n return complex(real, imaginary)\n \n @staticmethod\n def multiply(c1, c2):\n real = c1.real * c2.real - c1.imag * c2.imag\n imaginary = c1.real * c2.imag + c1.imag * c2.real\n return complex(real, imaginary)\n \n @staticmethod\n def divide(c1, c2):\n denominator = c2.real**2 + c2.imag**2\n real = (c1.real * c2.real + c1.imag * c2.imag) / denominator\n imaginary = (c1.imag * c2.real - c1.real * c2.imag) / denominator\n return complex(real, imaginary)", "inputs": ["complexCalculator = ComplexCalculator()\nassertEqual(complexCalculator.add(1+2j, 3+4j), (4+6j))\n", "complexCalculator = ComplexCalculator()\nassertEqual(complexCalculator.subtract(1+2j, 3+4j), (-2-2j))\n", "complexCalculator = ComplexCalculator()\nassertEqual(complexCalculator.multiply(1+2j, 3+4j), (-5+10j))\n", "complexCalculator = ComplexCalculator()\nassertEqual(complexCalculator.divide(1+2j, 3+4j), (0.44+0.08j))\n", "complexCalculator = ComplexCalculator()\nassertEqual(complexCalculator.add(1+2j, 3+4j), (4+6j))\nassertEqual(complexCalculator.subtract(1+2j, 3+4j), (-2-2j))\nassertEqual(complexCalculator.multiply(1+2j, 3+4j), (-5+10j))\nassertEqual(complexCalculator.divide(1+2j, 3+4j), (0.44+0.08j))\n"], "outputs": [], "test": "import unittest\n\nclass ComplexCalculatorTestAdd(unittest.TestCase):\n def test_add(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.add(1+2j, 3+4j), (4+6j))\n\n def test_add_2(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.add(-1 - 2j, -3 - 4j), (-4 - 6j))\n\n def test_add_3(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.add(1-2j, 3-4j), (4-6j))\n\n def test_add_4(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.add(-1+2j, -3+4j), (-4+6j))\n\n def test_add_5(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.add(1+2j, -1-2j), (0+0j))\n\nclass ComplexCalculatorTestSubtract(unittest.TestCase):\n def test_subtract(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.subtract(1+2j, 3+4j), (-2-2j))\n\n def test_subtract_2(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.subtract(-1-2j, -3-4j), (2+2j))\n\n def test_subtract_3(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.subtract(1-2j, 3-4j), (-2+2j))\n\n def test_subtract_4(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.subtract(-1+2j, -3+4j), (2-2j))\n\n def test_subtract_5(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.subtract(1+2j, 1+2j), (0+0j))\n\nclass ComplexCalculatorTestMultiply(unittest.TestCase):\n def test_multiply(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.multiply(1+2j, 3+4j), (-5+10j))\n\n def test_multiply_2(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.multiply(-1-2j, -3-4j), (-5+10j))\n\n def test_multiply_3(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.multiply(1-2j, 3-4j), (-5-10j))\n\n def test_multiply_4(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.multiply(-1+2j, -3+4j), (-5-10j))\n\n def test_multiply_5(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.multiply(1+2j, -1-2j), (3-4j))\n\nclass ComplexCalculatorTestDivide(unittest.TestCase):\n def test_divide(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.divide(1+2j, 3+4j), (0.44+0.08j))\n\n def test_divide_2(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.divide(-1-2j, -3-4j), (0.44+0.08j))\n\n def test_divide_3(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.divide(1-2j, 3-4j), (0.44-0.08j))\n\n def test_divide_4(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.divide(-1+2j, -3+4j), (0.44-0.08j))\n\n def test_divide_5(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.divide(1+2j, -1-2j), (-1+0j))\n\nclass ComplexCalculatorTestMain(unittest.TestCase):\n def test_main(self):\n complexCalculator = ComplexCalculator()\n self.assertEqual(complexCalculator.add(1+2j, 3+4j), (4+6j))\n self.assertEqual(complexCalculator.subtract(1+2j, 3+4j), (-2-2j))\n self.assertEqual(complexCalculator.multiply(1+2j, 3+4j), (-5+10j))\n self.assertEqual(complexCalculator.divide(1+2j, 3+4j), (0.44+0.08j))"} {"task_id": "DREval/104", "entry_point": "CurrencyConverter", "code": "class CurrencyConverter:\n def __init__(self):\n self.rates = {\n 'USD': 1.0,\n 'EUR': 0.85,\n 'GBP': 0.72,\n 'JPY': 110.15,\n 'CAD': 1.23,\n 'AUD': 1.34,\n 'CNY': 6.40,\n }\n\n def convert(self, amount, from_currency, to_currency):\n if from_currency == to_currency:\n return amount\n\n if from_currency not in self.rates or to_currency not in self.rates:\n return False\n\n from_rate = self.rates[from_currency]\n to_rate = self.rates[to_currency]\n\n converted_amount = (amount / from_rate) * to_rate\n return converted_amount\n\n def get_supported_currencies(self):\n return list(self.rates.keys())\n\n def add_currency_rate(self, currency, rate):\n if currency in self.rates:\n return False\n self.rates[currency] = rate\n\n def update_currency_rate(self, currency, new_rate):\n if currency not in self.rates:\n return False\n self.rates[currency] = new_rate", "inputs": ["cc = CurrencyConverter()\nres = cc.convert(64, 'CNY', 'USD')\nassertEqual(res, 10.0)\n", "cc = CurrencyConverter()\nres = cc.get_supported_currencies()\nassertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])\n", "cc = CurrencyConverter()\ncc.add_currency_rate('KRW', 1308.84)\nassertEqual(cc.rates['KRW'], 1308.84)\n", "cc = CurrencyConverter()\ncc.update_currency_rate('CNY', 7.18)\nassertEqual(cc.rates['CNY'], 7.18)\n", "cc = CurrencyConverter()\nres = cc.convert(64, 'CNY', 'USD')\nassertEqual(res, 10.0)\nres = cc.get_supported_currencies()\nassertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])\ncc.add_currency_rate('KRW', 1308.84)\nassertEqual(cc.rates['KRW'], 1308.84)\ncc.update_currency_rate('CNY', 7.18)\nassertEqual(cc.rates['CNY'], 7.18)\n"], "outputs": [], "test": "import unittest\n\n\nclass CurrencyConverterTestConvert(unittest.TestCase):\n def test_convert_1(self):\n cc = CurrencyConverter()\n res = cc.convert(64, 'CNY', 'USD')\n self.assertEqual(res, 10.0)\n\n def test_convert_2(self):\n cc = CurrencyConverter()\n res = cc.convert(64, 'USD', 'USD')\n self.assertEqual(res, 64)\n\n def test_convert_3(self):\n cc = CurrencyConverter()\n res = cc.convert(64, 'CNY', 'GBP')\n self.assertAlmostEqual(res, 7.1999999999999)\n\n def test_convert_4(self):\n cc = CurrencyConverter()\n res = cc.convert(64, 'USD', 'GBP')\n self.assertAlmostEqual(res, 46.08)\n\n def test_convert_5(self):\n cc = CurrencyConverter()\n res = cc.convert(64, 'USD', 'CAD')\n self.assertAlmostEqual(res, 78.72)\n\n def test_convert_6(self):\n cc = CurrencyConverter()\n res = cc.convert(64, '???', 'USD')\n self.assertFalse(res)\n\n\nclass CurrencyConverterTestGetSupportedCurrencies(unittest.TestCase):\n def test_get_supported_currencies_1(self):\n cc = CurrencyConverter()\n res = cc.get_supported_currencies()\n self.assertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])\n\n def test_get_supported_currencies_2(self):\n cc = CurrencyConverter()\n res = cc.get_supported_currencies()\n self.assertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])\n\n def test_get_supported_currencies_3(self):\n cc = CurrencyConverter()\n res = cc.get_supported_currencies()\n self.assertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])\n\n def test_get_supported_currencies_4(self):\n cc = CurrencyConverter()\n res = cc.get_supported_currencies()\n self.assertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])\n\n def test_get_supported_currencies_5(self):\n cc = CurrencyConverter()\n res = cc.get_supported_currencies()\n self.assertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])\n\n\nclass CurrencyConverterTestAddCurrencyRate(unittest.TestCase):\n def test_add_currency_rate_1(self):\n cc = CurrencyConverter()\n cc.add_currency_rate('KRW', 1308.84)\n self.assertEqual(cc.rates['KRW'], 1308.84)\n\n def test_add_currency_rate_2(self):\n cc = CurrencyConverter()\n cc.add_currency_rate('aaa', 1.0)\n self.assertEqual(cc.rates['aaa'], 1.0)\n\n def test_add_currency_rate_3(self):\n cc = CurrencyConverter()\n cc.add_currency_rate('bbb', 2.0)\n self.assertEqual(cc.rates['bbb'], 2.0)\n\n def test_add_currency_rate_4(self):\n cc = CurrencyConverter()\n cc.add_currency_rate('ccc', 3.0)\n self.assertEqual(cc.rates['ccc'], 3.0)\n\n def test_add_currency_rate_5(self):\n cc = CurrencyConverter()\n cc.add_currency_rate('ddd', 4.0)\n self.assertEqual(cc.rates['ddd'], 4.0)\n\n def test_add_currency_rate_6(self):\n cc = CurrencyConverter()\n res = cc.add_currency_rate('USD', 1.0)\n self.assertFalse(res)\n\n\nclass CurrencyConverterTestUpdateCurrencyRate(unittest.TestCase):\n def test_update_currency_rate_1(self):\n cc = CurrencyConverter()\n cc.update_currency_rate('CNY', 7.18)\n self.assertEqual(cc.rates['CNY'], 7.18)\n\n def test_update_currency_rate_2(self):\n cc = CurrencyConverter()\n cc.update_currency_rate('CNY', 1.0)\n self.assertEqual(cc.rates['CNY'], 1.0)\n\n def test_update_currency_rate_3(self):\n cc = CurrencyConverter()\n cc.update_currency_rate('CNY', 2.0)\n self.assertEqual(cc.rates['CNY'], 2.0)\n\n def test_update_currency_rate_4(self):\n cc = CurrencyConverter()\n cc.update_currency_rate('CNY', 3.0)\n self.assertEqual(cc.rates['CNY'], 3.0)\n\n def test_update_currency_rate_5(self):\n cc = CurrencyConverter()\n cc.update_currency_rate('CNY', 4.0)\n self.assertEqual(cc.rates['CNY'], 4.0)\n\n def test_update_currency_rate_6(self):\n cc = CurrencyConverter()\n res = cc.update_currency_rate('???', 7.18)\n self.assertFalse(res)\n\n\nclass CurrencyConverterTest(unittest.TestCase):\n def test_currencyconverter(self):\n cc = CurrencyConverter()\n res = cc.convert(64, 'CNY', 'USD')\n self.assertEqual(res, 10.0)\n res = cc.get_supported_currencies()\n self.assertEqual(res, ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CNY'])\n cc.add_currency_rate('KRW', 1308.84)\n self.assertEqual(cc.rates['KRW'], 1308.84)\n cc.update_currency_rate('CNY', 7.18)\n self.assertEqual(cc.rates['CNY'], 7.18)"} {"task_id": "DREval/105", "entry_point": "DataStatistics", "code": "from collections import Counter\n\n\nclass DataStatistics:\n def mean(self, data):\n return round(sum(data) / len(data), 2)\n\n def median(self, data):\n sorted_data = sorted(data)\n n = len(sorted_data)\n if n % 2 == 0:\n middle = n // 2\n return round((sorted_data[middle - 1] + sorted_data[middle]) / 2, 2)\n else:\n middle = n // 2\n return sorted_data[middle]\n\n def mode(self, data):\n counter = Counter(data)\n mode_count = max(counter.values())\n mode = [x for x, count in counter.items() if count == mode_count]\n return mode", "inputs": ["ds = DataStatistics()\nres = ds.mean([1, 2, 3, 4, 5])\nassertEqual(res, 3.00)\n", "ds = DataStatistics()\nres = ds.median([2, 5, 1, 3, 4])\nassertEqual(res, 3)\n", "ds = DataStatistics()\nres = ds.mode([2, 2, 3, 3, 4])\nassertEqual(res, [2, 3])\n", "ds = DataStatistics()\nres = ds.mean([1, 2, 3, 4, 5])\nassertEqual(res, 3.00)\nres = ds.median([2, 5, 1, 3, 4])\nassertEqual(res, 3.00)\nres = ds.mode([2, 2, 3, 3, 4])\nassertEqual(res, [2, 3])\n"], "outputs": [], "test": "import unittest\n\n\nclass DataStatisticsTestMean(unittest.TestCase):\n def test_mean_1(self):\n ds = DataStatistics()\n res = ds.mean([1, 2, 3, 4, 5])\n self.assertEqual(res, 3.00)\n\n def test_mean_2(self):\n ds = DataStatistics()\n res = ds.mean([1, 2, 3, 4, 5, 6])\n self.assertEqual(res, 3.50)\n\n def test_mean_3(self):\n ds = DataStatistics()\n res = ds.mean([1, 2, 4, 5, 6, 7])\n self.assertEqual(res, 4.17)\n\n def test_mean_4(self):\n ds = DataStatistics()\n res = ds.mean([1, 2, 4, 5, 6, 7, 8])\n self.assertEqual(res, 4.71)\n\n def test_mean_5(self):\n ds = DataStatistics()\n res = ds.mean([1, 2, 4, 5, 6, 7, 8, 9])\n self.assertEqual(res, 5.25)\n\n\nclass DataStatisticsTestMedian(unittest.TestCase):\n def test_median_1(self):\n ds = DataStatistics()\n res = ds.median([2, 5, 1, 3, 4])\n self.assertEqual(res, 3)\n\n def test_median_2(self):\n ds = DataStatistics()\n res = ds.median([2, 5, 1, 3, 4, 6])\n self.assertEqual(res, 3.50)\n\n def test_median_3(self):\n ds = DataStatistics()\n res = ds.median([2, 5, 1, 4, 6, 7])\n self.assertEqual(res, 4.5)\n\n def test_median_4(self):\n ds = DataStatistics()\n res = ds.median([2, 5, 1, 4, 6, 7, 8])\n self.assertEqual(res, 5)\n\n def test_median_5(self):\n ds = DataStatistics()\n res = ds.median([2, 5, 1, 4, 6, 7, 8, 9])\n self.assertEqual(res, 5.5)\n\n\nclass DataStatisticsTestMode(unittest.TestCase):\n def test_mode_1(self):\n ds = DataStatistics()\n res = ds.mode([2, 2, 3, 3, 4])\n self.assertEqual(res, [2, 3])\n\n def test_mode_2(self):\n ds = DataStatistics()\n res = ds.mode([2, 2, 2, 3, 3, 4])\n self.assertEqual(res, [2])\n\n def test_mode_3(self):\n ds = DataStatistics()\n res = ds.mode([2, 2, 3, 3, 4, 4])\n self.assertEqual(res, [2, 3, 4])\n\n def test_mode_4(self):\n ds = DataStatistics()\n res = ds.mode([2, 2, 3, 3, 4, 4, 4])\n self.assertEqual(res, [4])\n\n def test_mode_5(self):\n ds = DataStatistics()\n res = ds.mode([2, 2, 3, 3, 4, 4, 4, 5])\n self.assertEqual(res, [4])\n\n\nclass DataStatisticsTest(unittest.TestCase):\n def test_datastatistics(self):\n ds = DataStatistics()\n res = ds.mean([1, 2, 3, 4, 5])\n self.assertEqual(res, 3.00)\n res = ds.median([2, 5, 1, 3, 4])\n self.assertEqual(res, 3.00)\n res = ds.mode([2, 2, 3, 3, 4])\n self.assertEqual(res, [2, 3])"} {"task_id": "DREval/106", "entry_point": "DataStatistics2", "code": "import numpy as np\n\n\nclass DataStatistics2:\n def __init__(self, data):\n self.data = np.array(data)\n\n def get_sum(self):\n return np.sum(self.data)\n\n def get_min(self):\n return np.min(self.data)\n\n def get_max(self):\n return np.max(self.data)\n\n def get_variance(self):\n return round(np.var(self.data), 2)\n\n def get_std_deviation(self):\n return round(np.std(self.data), 2)\n\n def get_correlation(self):\n return np.corrcoef(self.data, rowvar=False)", "inputs": ["ds2 = DataStatistics2([1, 2, 3, 4])\nres = ds2.get_sum()\nassertEqual(res, 10)\n", "ds2 = DataStatistics2([1, 2, 3, 4])\nres = ds2.get_min()\nassertEqual(res, 1)\n", "ds2 = DataStatistics2([1, 2, 3, 4])\nres = ds2.get_max()\nassertEqual(res, 4)\n", "ds2 = DataStatistics2([1, 2, 3, 4])\nres = ds2.get_variance()\nassertEqual(res, 1.25)\n", "ds2 = DataStatistics2([1, 2, 3, 4])\nres = ds2.get_std_deviation()\nassertEqual(res, 1.12)\n", "ds2 = DataStatistics2([1, 2, 3, 4])\nres = ds2.get_correlation()\nassertEqual(res, 1.0)\n", "ds2 = DataStatistics2([1, 2, 3, 4])\nres = ds2.get_sum()\nassertEqual(res, 10)\nres = ds2.get_min()\nassertEqual(res, 1)\nres = ds2.get_max()\nassertEqual(res, 4)\nres = ds2.get_variance()\nassertEqual(res, 1.25)\nres = ds2.get_std_deviation()\nassertEqual(res, 1.12)\nres = ds2.get_correlation()\nassertEqual(res, 1.0)\n"], "outputs": [], "test": "import unittest\n\n\nclass DataStatistics2TestGetSum(unittest.TestCase):\n def test_get_sum_1(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_sum()\n self.assertEqual(res, 10)\n\n def test_get_sum_2(self):\n ds2 = DataStatistics2([1, 2, 203, 4])\n res = ds2.get_sum()\n self.assertEqual(res, 210)\n\n def test_get_sum_3(self):\n ds2 = DataStatistics2([1, 2, 33, 4])\n res = ds2.get_sum()\n self.assertEqual(res, 40)\n\n def test_get_sum_4(self):\n ds2 = DataStatistics2([1, 2, 333, 4])\n res = ds2.get_sum()\n self.assertEqual(res, 340)\n\n def test_get_sum_5(self):\n ds2 = DataStatistics2([1, 2, 6, 4])\n res = ds2.get_sum()\n self.assertEqual(res, 13)\n\n\nclass DataStatistics2TestGetMin(unittest.TestCase):\n def test_get_min_1(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_min()\n self.assertEqual(res, 1)\n\n def test_get_min_2(self):\n ds2 = DataStatistics2([1, 2, 203, 4])\n res = ds2.get_min()\n self.assertEqual(res, 1)\n\n def test_get_min_3(self):\n ds2 = DataStatistics2([0, -1, -3, 2])\n res = ds2.get_min()\n self.assertEqual(res, -3)\n\n def test_get_min_4(self):\n ds2 = DataStatistics2([-111, -1, -3, 2])\n res = ds2.get_min()\n self.assertEqual(res, -111)\n\n def test_get_min_5(self):\n ds2 = DataStatistics2([0, -1111, -3, 2])\n res = ds2.get_min()\n self.assertEqual(res, -1111)\n\n\nclass DataStatistics2TestGetMax(unittest.TestCase):\n def test_get_max_1(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_max()\n self.assertEqual(res, 4)\n\n def test_get_max_2(self):\n ds2 = DataStatistics2([1, 2, 203, 4])\n res = ds2.get_max()\n self.assertEqual(res, 203)\n\n def test_get_max_3(self):\n ds2 = DataStatistics2([-1, -4, 3, 2])\n res = ds2.get_max()\n self.assertEqual(res, 3)\n\n def test_get_max_4(self):\n ds2 = DataStatistics2([-1, 4, 3, 2])\n res = ds2.get_max()\n self.assertEqual(res, 4)\n\n def test_get_max_5(self):\n ds2 = DataStatistics2([-1, 444, 3, 2])\n res = ds2.get_max()\n self.assertEqual(res, 444)\n\n\nclass DataStatistics2TestGetVariance(unittest.TestCase):\n def test_get_variance_1(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_variance()\n self.assertEqual(res, 1.25)\n\n def test_get_variance_2(self):\n ds2 = DataStatistics2([1, 2, 203, 4])\n res = ds2.get_variance()\n self.assertEqual(res, 7551.25)\n\n def test_get_variance_3(self):\n ds2 = DataStatistics2([1, 4, 3, 2])\n res = ds2.get_variance()\n self.assertEqual(res, 1.25)\n\n def test_get_variance_4(self):\n ds2 = DataStatistics2([11, 14, 13, 12])\n res = ds2.get_variance()\n self.assertEqual(res, 1.25)\n\n def test_get_variance_5(self):\n ds2 = DataStatistics2([111, 114, 113, 112])\n res = ds2.get_variance()\n self.assertEqual(res, 1.25)\n\n\nclass DataStatistics2TestGetStdDeviation(unittest.TestCase):\n def test_get_std_deviation_1(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_std_deviation()\n self.assertEqual(res, 1.12)\n\n def test_get_std_deviation_2(self):\n ds2 = DataStatistics2([1, 2, 203, 4])\n res = ds2.get_std_deviation()\n self.assertEqual(res, 86.9)\n\n def test_get_std_deviation_3(self):\n ds2 = DataStatistics2([1, 4, 3, 2])\n res = ds2.get_std_deviation()\n self.assertEqual(res, 1.12)\n\n def test_get_std_deviation_4(self):\n ds2 = DataStatistics2([11, 14, 13, 12])\n res = ds2.get_std_deviation()\n self.assertEqual(res, 1.12)\n\n def test_get_std_deviation_5(self):\n ds2 = DataStatistics2([111, 114, 113, 112])\n res = ds2.get_std_deviation()\n self.assertEqual(res, 1.12)\n\n\nclass DataStatistics2TestGetCorrelation(unittest.TestCase):\n def test_get_correlation_1(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_correlation()\n self.assertEqual(res, 1.0)\n\n def test_get_correlation_2(self):\n ds2 = DataStatistics2([1, 2, 203, 4])\n res = ds2.get_correlation()\n self.assertEqual(res, 1.0)\n\n def test_get_correlation_3(self):\n ds2 = DataStatistics2([1, 4, 3, 2])\n res = ds2.get_correlation()\n self.assertEqual(res, 1.0)\n\n def test_get_correlation_4(self):\n ds2 = DataStatistics2([11, 14, 13, 12])\n res = ds2.get_correlation()\n self.assertEqual(res, 1.0)\n\n def test_get_correlation_5(self):\n ds2 = DataStatistics2([111, 114, 113, 112])\n res = ds2.get_correlation()\n self.assertEqual(res, 1.0)\n\n\nclass DataStatistics2Test(unittest.TestCase):\n def test_datastatistics2(self):\n ds2 = DataStatistics2([1, 2, 3, 4])\n res = ds2.get_sum()\n self.assertEqual(res, 10)\n\n res = ds2.get_min()\n self.assertEqual(res, 1)\n\n res = ds2.get_max()\n self.assertEqual(res, 4)\n\n res = ds2.get_variance()\n self.assertEqual(res, 1.25)\n\n res = ds2.get_std_deviation()\n self.assertEqual(res, 1.12)\n\n res = ds2.get_correlation()\n self.assertEqual(res, 1.0)"} {"task_id": "DREval/107", "entry_point": "DataStatistics4", "code": "import math\n\nclass DataStatistics4:\n\n @staticmethod\n def correlation_coefficient(data1, data2):\n n = len(data1)\n mean1 = sum(data1) / n\n mean2 = sum(data2) / n\n\n numerator = sum((data1[i] - mean1) * (data2[i] - mean2) for i in range(n))\n denominator = math.sqrt(sum((data1[i] - mean1) ** 2 for i in range(n))) * math.sqrt(sum((data2[i] - mean2) ** 2 for i in range(n)))\n\n return numerator / denominator if denominator != 0 else 0\n \n @staticmethod\n def skewness(data):\n n = len(data)\n mean = sum(data) / n\n variance = sum((x - mean) ** 2 for x in data) / n\n std_deviation = math.sqrt(variance)\n\n skewness = sum((x - mean) ** 3 for x in data) * n / ((n - 1) * (n - 2) * std_deviation ** 3) if std_deviation != 0 else 0\n\n return skewness\n \n @staticmethod\n def kurtosis(data):\n\n n = len(data)\n mean = sum(data) / n\n std_dev = math.sqrt(sum((x - mean) ** 2 for x in data) / n)\n\n if std_dev == 0:\n return math.nan\n\n centered_data = [(x - mean) for x in data]\n fourth_moment = sum(x ** 4 for x in centered_data) / n\n\n kurtosis_value = (fourth_moment / std_dev ** 4) - 3\n\n return kurtosis_value\n \n @staticmethod\n def pdf(data, mu, sigma):\n pdf_values = [1 / (sigma * math.sqrt(2 * math.pi)) * math.exp(-0.5 * ((x - mu) / sigma) ** 2) for x in data]\n return pdf_values", "inputs": ["assertEqual(DataStatistics4.correlation_coefficient([1, 2, 3], [4, 5, 6]), 0.9999999999999998)\n", "assertEqual(DataStatistics4.skewness([1, 2, 5]), 2.3760224064818463)\n", "assertEqual(DataStatistics4.kurtosis([1, 2, 5]), -1.5000000000000002)\n", "assertEqual(DataStatistics4.pdf([1, 2, 3], 1, 1),\n[0.3989422804014327, 0.24197072451914337, 0.05399096651318806])\n", "assertEqual(DataStatistics4.correlation_coefficient([1, 2, 3], [4, 5, 6]), 0.9999999999999998)\nassertEqual(DataStatistics4.skewness([1, 2, 5]), 2.3760224064818463)\nassertEqual(DataStatistics4.kurtosis([1, 2, 5]), -1.5000000000000002)\nassertEqual(DataStatistics4.pdf([1, 2, 3], 1, 1),\n[0.3989422804014327, 0.24197072451914337, 0.05399096651318806])\n"], "outputs": [], "test": "import unittest\n\n\nclass DataStatistics4TestCorrelationCoefficient(unittest.TestCase):\n def test_correlation_coefficient(self):\n self.assertEqual(DataStatistics4.correlation_coefficient([1, 2, 3], [4, 5, 6]), 0.9999999999999998)\n\n def test_correlation_coefficient_2(self):\n self.assertEqual(DataStatistics4.correlation_coefficient([1, 1, 1], [2, 2, 2]), 0)\n\n def test_correlation_coefficient_3(self):\n self.assertEqual(DataStatistics4.correlation_coefficient([1, 2, 3], [1, 2, 3]), 0.9999999999999998)\n\n def test_correlation_coefficient_4(self):\n self.assertEqual(DataStatistics4.correlation_coefficient([1, 2, 3], [1, 2, 4]), 0.9819805060619659)\n\n def test_correlation_coefficient_5(self):\n self.assertEqual(DataStatistics4.correlation_coefficient([1, 2, 3], [1, 5, 3]), 0.4999999999999999)\n\n\nclass DataStatistics4TestSkewness(unittest.TestCase):\n def test_skewness(self):\n self.assertEqual(DataStatistics4.skewness([1, 2, 5]), 2.3760224064818463)\n\n def test_skewness_2(self):\n self.assertEqual(DataStatistics4.skewness([1, 1, 1]), 0)\n\n def test_skewness_3(self):\n self.assertEqual(DataStatistics4.skewness([1, 2, 3]), 0)\n\n def test_skewness_4(self):\n self.assertEqual(DataStatistics4.skewness([1, 2, 4]), 1.7181079837227264)\n\n def test_skewness_5(self):\n self.assertEqual(DataStatistics4.skewness([1, 5, 3]), 0.0)\n\n\nclass DataStatistics4TestKurtosis(unittest.TestCase):\n def test_kurtosis(self):\n self.assertEqual(DataStatistics4.kurtosis([1, 2, 5]), -1.5000000000000002)\n\n def test_kurtosis_2(self):\n self.assertTrue(math.isnan(DataStatistics4.kurtosis([1, 1, 1])))\n\n def test_kurtosis_3(self):\n self.assertEqual(DataStatistics4.kurtosis([1, 2, 3]), -1.5000000000000002)\n\n def test_kurtosis_4(self):\n self.assertEqual(DataStatistics4.kurtosis([1, 2, 4]), -1.4999999999999996)\n\n def test_kurtosis_5(self):\n self.assertEqual(DataStatistics4.kurtosis([1, 5, 3]), -1.5000000000000002)\n\n\nclass DataStatistics4TestPDF(unittest.TestCase):\n def test_pdf(self):\n self.assertEqual(DataStatistics4.pdf([1, 2, 3], 1, 1),\n [0.3989422804014327, 0.24197072451914337, 0.05399096651318806])\n\n def test_pdf_2(self):\n self.assertEqual(DataStatistics4.pdf([1, 1, 1], 1, 1),\n [0.3989422804014327, 0.3989422804014327, 0.3989422804014327])\n\n def test_pdf_3(self):\n self.assertEqual(DataStatistics4.pdf([1, 2, 3], 2, 1),\n [0.24197072451914337, 0.3989422804014327, 0.24197072451914337])\n\n def test_pdf_4(self):\n self.assertEqual(DataStatistics4.pdf([1, 2, 3], 1, 2),\n [0.19947114020071635, 0.17603266338214976, 0.12098536225957168])\n\n def test_pdf_5(self):\n self.assertEqual(DataStatistics4.pdf([1, 2, 3], 2, 2),\n [0.17603266338214976, 0.19947114020071635, 0.17603266338214976])\n\n\nclass DataStatistics4TestMain(unittest.TestCase):\n def test_main(self):\n self.assertEqual(DataStatistics4.correlation_coefficient([1, 2, 3], [4, 5, 6]), 0.9999999999999998)\n self.assertEqual(DataStatistics4.skewness([1, 2, 5]), 2.3760224064818463)\n self.assertEqual(DataStatistics4.kurtosis([1, 2, 5]), -1.5000000000000002)\n self.assertEqual(DataStatistics4.pdf([1, 2, 3], 1, 1),\n [0.3989422804014327, 0.24197072451914337, 0.05399096651318806])"} {"task_id": "DREval/108", "entry_point": "DecryptionUtils", "code": "class DecryptionUtils:\n def __init__(self, key):\n self.key = key\n \n def caesar_decipher(self, ciphertext, shift):\n plaintext = \"\"\n for char in ciphertext:\n if char.isalpha():\n if char.isupper():\n ascii_offset = 65\n else:\n ascii_offset = 97\n shifted_char = chr((ord(char) - ascii_offset - shift) % 26 + ascii_offset)\n plaintext += shifted_char\n else:\n plaintext += char\n return plaintext\n \n def vigenere_decipher(self, ciphertext):\n decrypted_text = \"\"\n key_index = 0\n for char in ciphertext:\n if char.isalpha():\n shift = ord(self.key[key_index % len(self.key)].lower()) - ord('a')\n decrypted_char = chr((ord(char.lower()) - ord('a') - shift) % 26 + ord('a'))\n decrypted_text += decrypted_char.upper() if char.isupper() else decrypted_char\n key_index += 1\n else:\n decrypted_text += char\n return decrypted_text\n \n def rail_fence_decipher(self, encrypted_text, rails):\n fence = [['\\n' for _ in range(len(encrypted_text))] for _ in range(rails)]\n direction = -1\n row, col = 0, 0\n\n for _ in range(len(encrypted_text)):\n if row == 0 or row == rails - 1:\n direction = -direction\n\n fence[row][col] = ''\n col += 1\n row += direction\n\n index = 0\n for i in range(rails):\n for j in range(len(encrypted_text)):\n if fence[i][j] == '':\n fence[i][j] = encrypted_text[index]\n index += 1\n\n plain_text = ''\n direction = -1\n row, col = 0, 0\n for _ in range(len(encrypted_text)):\n if row == 0 or row == rails - 1:\n direction = -direction\n\n plain_text += fence[row][col]\n col += 1\n row += direction\n\n return plain_text", "inputs": ["d = DecryptionUtils('key')\nassertEqual(d.caesar_decipher('ifmmp', 1), 'hello')\n", "d = DecryptionUtils('key')\nassertEqual(d.vigenere_decipher('ifmmp'), 'ybocl')\n", "d = DecryptionUtils('key')\nassertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 3), 'Hello, World!')\n", "d = DecryptionUtils('key')\nassertEqual(d.caesar_decipher('ifmmp', 1), 'hello')\nassertEqual(d.vigenere_decipher('ifmmp'), 'ybocl')\nassertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 3), 'Hello, World!')\n"], "outputs": [], "test": "import unittest\n\n\nclass DecryptionUtilsTestCaesarDecipher(unittest.TestCase):\n def test_caesar_decipher(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('ifmmp', 1), 'hello')\n\n def test_caesar_decipher_2(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('bcdyza', 27), 'abcxyz')\n\n def test_caesar_decipher_3(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('bcd', 0), 'bcd')\n\n def test_caesar_decipher_4(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('bcd', 26), 'bcd')\n\n def test_caesar_decipher_5(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('bcd', -26), 'bcd')\n\n def test_caesar_decipher_6(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('IFMMP', 1), 'HELLO')\n\n def test_caesar_decipher_7(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('123', 1), '123')\n\n\nclass DecryptionUtilsTestVigenereDecipher(unittest.TestCase):\n def test_vigenere_decipher(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.vigenere_decipher('ifmmp'), 'ybocl')\n\n def test_vigenere_decipher_2(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.vigenere_decipher('rijvs'), 'hello')\n\n def test_vigenere_decipher_3(self):\n d = DecryptionUtils('longkey')\n self.assertEqual(d.vigenere_decipher('LpPjOjE'), 'AbCdEfG')\n\n def test_vigenere_decipher_4(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.vigenere_decipher('bcd'), 'ryf')\n\n def test_vigenere_decipher_5(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.vigenere_decipher('bcdaa'), 'ryfqw')\n\n def test_vigenere_decipher_6(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.vigenere_decipher('123'), '123')\n\n\nclass DecryptionUtilsTestRailFenceDecipher(unittest.TestCase):\n def test_rail_fence_decipher(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 3), 'Hello, World!')\n\n def test_rail_fence_decipher_2(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 4), 'H!W reoldll,o')\n\n def test_rail_fence_decipher_3(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 5), 'Holr d,!oeWll')\n\n def test_rail_fence_decipher_4(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 6), 'Holrll d,!oeW')\n\n def test_rail_fence_decipher_5(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 7), 'Hoe,rll dWl!o')\n\n\nclass DecryptionUtilsTestMain(unittest.TestCase):\n def test_main(self):\n d = DecryptionUtils('key')\n self.assertEqual(d.caesar_decipher('ifmmp', 1), 'hello')\n self.assertEqual(d.vigenere_decipher('ifmmp'), 'ybocl')\n self.assertEqual(d.rail_fence_decipher('Hoo!el,Wrdl l', 3), 'Hello, World!')"} {"task_id": "DREval/109", "entry_point": "DiscountStrategy", "code": "class DiscountStrategy:\n def __init__(self, customer, cart, promotion=None):\n self.customer = customer\n self.cart = cart\n self.promotion = promotion\n self.__total = self.total()\n\n def total(self):\n self.__total = sum(item['quantity'] * item['price'] for item in self.cart)\n return self.__total\n\n def due(self):\n if self.promotion is None:\n discount = 0\n else:\n discount = self.promotion(self)\n return self.__total - discount\n\n @staticmethod\n def FidelityPromo(order):\n return order.total() * 0.05 if order.customer['fidelity'] >= 1000 else 0\n\n @staticmethod\n def BulkItemPromo(order):\n discount = 0\n for item in order.cart:\n if item['quantity'] >= 20:\n discount += item['quantity'] * item['price'] * 0.1\n return discount\n\n @staticmethod\n def LargeOrderPromo(order):\n return order.total() * 0.07 if len({item['product'] for item in order.cart}) >= 10 else 0", "inputs": ["customer = {'name': 'John Doe', 'fidelity': 1200}\ncart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n{'product': 'product2', 'quantity': 5, 'price': 10.0}]\norder = DiscountStrategy(customer, cart)\nexpected_total = 250.0\nactual_total = order.total()\nassertEqual(actual_total, expected_total)\n", "customer = {'name': 'John Doe', 'fidelity': 1200}\ncart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n{'product': 'product2', 'quantity': 5, 'price': 10.0}]\norder = DiscountStrategy(customer, cart)\nexpected_due = 250.0\nactual_due = order.due()\nassertEqual(actual_due, expected_due)\n", "customer = {'name': 'John Doe', 'fidelity': 1000}\ncart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n{'product': 'product2', 'quantity': 5, 'price': 10.0}]\norder = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\nexpected_discount = 12.5\nactual_discount = order.promotion(order)\nassertEqual(actual_discount, expected_discount)\n", "customer = {'name': 'John Doe', 'fidelity': 1200}\ncart = [{'product': 'product1', 'quantity': 20, 'price': 10.0},\n{'product': 'product2', 'quantity': 5, 'price': 5.0}]\norder = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\nexpected_discount = 20.0\nactual_discount = order.promotion(order)\nassertEqual(actual_discount, expected_discount)\n", "customer = {'name': 'John Doe', 'fidelity': 1200}\ncart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(10)]\norder = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\nexpected_discount = 7.0\nactual_discount = order.promotion(order)\nassertAlmostEqual(actual_discount, expected_discount)\n", "customer = {'name': 'John Doe', 'fidelity': 1200}\ncart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n{'product': 'product2', 'quantity': 5, 'price': 10.0}]\norder = DiscountStrategy(customer, cart)\nexpected_total = 250.0\nactual_total = order.total()\nassertEqual(actual_total, expected_total)\ncustomer = {'name': 'John Doe', 'fidelity': 1200}\ncart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n{'product': 'product2', 'quantity': 5, 'price': 10.0}]\norder = DiscountStrategy(customer, cart)\nexpected_due = 250.0\nactual_due = order.due()\nassertEqual(actual_due, expected_due)\ncustomer = {'name': 'John Doe', 'fidelity': 1000}\ncart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n{'product': 'product2', 'quantity': 5, 'price': 10.0}]\norder = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\nexpected_discount = 12.5\nactual_discount = order.promotion(order)\nassertEqual(actual_discount, expected_discount)\ncustomer = {'name': 'John Doe', 'fidelity': 1200}\ncart = [{'product': 'product1', 'quantity': 20, 'price': 10.0},\n{'product': 'product2', 'quantity': 5, 'price': 5.0}]\norder = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\nexpected_discount = 20.0\nactual_discount = order.promotion(order)\nassertEqual(actual_discount, expected_discount)\ncustomer = {'name': 'John Doe', 'fidelity': 1200}\ncart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(10)]\norder = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\nexpected_discount = 7.0\nactual_discount = order.promotion(order)\nassertAlmostEqual(actual_discount, expected_discount)\n"], "outputs": [], "test": "import unittest\n\n\nclass DiscountStrategyTestTotal(unittest.TestCase):\n def test_total_1(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart)\n expected_total = 250.0\n actual_total = order.total()\n self.assertEqual(actual_total, expected_total)\n\n def test_total_2(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart)\n expected_total = 150.0\n actual_total = order.total()\n self.assertEqual(actual_total, expected_total)\n\n def test_total_3(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 200.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart)\n expected_total = 2050.0\n actual_total = order.total()\n self.assertEqual(actual_total, expected_total)\n\n def test_total_4(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 1, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart)\n expected_total = 70.0\n actual_total = order.total()\n self.assertEqual(actual_total, expected_total)\n\n def test_total_5(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = []\n order = DiscountStrategy(customer, cart)\n expected_total = 0\n actual_total = order.total()\n self.assertEqual(actual_total, expected_total)\n\n\nclass DiscountStrategyTestDue(unittest.TestCase):\n def test_due_1(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart)\n expected_due = 250.0\n actual_due = order.due()\n self.assertEqual(actual_due, expected_due)\n\n def test_due_2(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_due = 237.5\n actual_due = order.due()\n self.assertEqual(actual_due, expected_due)\n\n def test_due_3(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 20, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_due = 410.0\n actual_due = order.due()\n self.assertEqual(actual_due, expected_due)\n\n def test_due_4(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(15)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_due = 139.5\n actual_due = order.due()\n self.assertEqual(actual_due, expected_due)\n\n def test_due_5(self):\n customer = {'name': 'John Doe', 'fidelity': 900}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_due = 250.0\n actual_due = order.due()\n self.assertEqual(actual_due, expected_due)\n\n\nclass DiscountStrategyTestFidelityPromo(unittest.TestCase):\n def test_fidelity_promo_1(self):\n customer = {'name': 'John Doe', 'fidelity': 1000}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_discount = 12.5\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_fidelity_promo_2(self):\n customer = {'name': 'John Doe', 'fidelity': 800}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_discount = 0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_fidelity_promo_3(self):\n customer = {'name': 'John Doe', 'fidelity': 0}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_discount = 0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_fidelity_promo_4(self):\n customer = {'name': 'John Doe', 'fidelity': 10000}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_discount = 12.5\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_fidelity_promo_5(self):\n customer = {'name': 'John Doe', 'fidelity': 1800}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_discount = 12.5\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n\nclass DiscountStrategyTestBulkItemPromo(unittest.TestCase):\n def test_bulk_item_promo_1(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 20, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 5.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_discount = 20.0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_bulk_item_promo_2(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 5.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_discount = 0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_bulk_item_promo_3(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 100, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 5.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_discount = 100.0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_bulk_item_promo_4(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 1, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 5.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_discount = 0.0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_bulk_item_promo_5(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 30, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 5.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_discount = 30.0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n\nclass DiscountStrategyTestLargeOrderPromo(unittest.TestCase):\n def test_large_order_promo_1(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(10)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_discount = 7.0\n actual_discount = order.promotion(order)\n self.assertAlmostEqual(actual_discount, expected_discount)\n\n def test_large_order_promo_2(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(5)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_discount = 0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n def test_large_order_promo_3(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(100)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_discount = 70.0\n actual_discount = order.promotion(order)\n self.assertAlmostEqual(actual_discount, expected_discount)\n\n def test_large_order_promo_4(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(1000)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_discount = 700.0\n actual_discount = order.promotion(order)\n self.assertAlmostEqual(actual_discount, expected_discount)\n\n def test_large_order_promo_5(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(1)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_discount = 0.0\n actual_discount = order.promotion(order)\n self.assertAlmostEqual(actual_discount, expected_discount)\n\n\nclass DiscountStrategyTest(unittest.TestCase):\n def test_DiscountStrategy(self):\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart)\n expected_total = 250.0\n actual_total = order.total()\n self.assertEqual(actual_total, expected_total)\n\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart)\n expected_due = 250.0\n actual_due = order.due()\n self.assertEqual(actual_due, expected_due)\n\n customer = {'name': 'John Doe', 'fidelity': 1000}\n cart = [{'product': 'product1', 'quantity': 10, 'price': 20.0},\n {'product': 'product2', 'quantity': 5, 'price': 10.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.FidelityPromo)\n expected_discount = 12.5\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': 'product1', 'quantity': 20, 'price': 10.0},\n {'product': 'product2', 'quantity': 5, 'price': 5.0}]\n order = DiscountStrategy(customer, cart, DiscountStrategy.BulkItemPromo)\n expected_discount = 20.0\n actual_discount = order.promotion(order)\n self.assertEqual(actual_discount, expected_discount)\n\n customer = {'name': 'John Doe', 'fidelity': 1200}\n cart = [{'product': f'product{i}', 'quantity': 1, 'price': 10.0} for i in range(10)]\n order = DiscountStrategy(customer, cart, DiscountStrategy.LargeOrderPromo)\n expected_discount = 7.0\n actual_discount = order.promotion(order)\n self.assertAlmostEqual(actual_discount, expected_discount)"} {"task_id": "DREval/110", "entry_point": "EightPuzzle", "code": "class EightPuzzle:\n def __init__(self, initial_state):\n self.initial_state = initial_state\n self.goal_state = [[1, 2, 3], [4, 5, 6], [7, 8, 0]]\n\n def find_blank(self, state):\n for i in range(3):\n for j in range(3):\n if state[i][j] == 0:\n return i, j\n\n def move(self, state, direction):\n i, j = self.find_blank(state)\n new_state = [row[:] for row in state]\n\n if direction == 'up':\n new_state[i][j], new_state[i - 1][j] = new_state[i - 1][j], new_state[i][j]\n elif direction == 'down':\n new_state[i][j], new_state[i + 1][j] = new_state[i + 1][j], new_state[i][j]\n elif direction == 'left':\n new_state[i][j], new_state[i][j - 1] = new_state[i][j - 1], new_state[i][j]\n elif direction == 'right':\n new_state[i][j], new_state[i][j + 1] = new_state[i][j + 1], new_state[i][j]\n\n return new_state\n\n def get_possible_moves(self, state):\n moves = []\n i, j = self.find_blank(state)\n\n if i > 0:\n moves.append('up')\n if i < 2:\n moves.append('down')\n if j > 0:\n moves.append('left')\n if j < 2:\n moves.append('right')\n\n return moves\n\n def solve(self):\n open_list = [(self.initial_state, [])]\n closed_list = []\n\n while open_list:\n current_state, path = open_list.pop(0)\n closed_list.append(current_state)\n\n if current_state == self.goal_state:\n return path\n\n for move in self.get_possible_moves(current_state):\n new_state = self.move(current_state, move)\n if new_state not in closed_list:\n open_list.append((new_state, path + [move]))\n\n return None", "inputs": ["state = [[2, 3, 4], [5, 8, 1], [6, 0, 7]]\neightPuzzle = EightPuzzle(state)\nassertEqual(eightPuzzle.find_blank(state), (2, 1))\n", "result = self.eightPuzzle.move(self.initial_state, 'up')\nexpected = [[2, 0, 4], [5, 3, 1], [6, 8, 7]]\nassertEqual(result, expected)\n", "eightPuzzle = EightPuzzle(None)\nstate = [[2, 3, 4], [5, 0, 1], [6, 8, 7]]\nresult = eightPuzzle.get_possible_moves(state)\nexpected = ['up', 'down', 'left', 'right']\nfor direction in result:\n\tassertIn(direction, expected)\n", "eightPuzzle = EightPuzzle([[1, 2, 3], [4, 5, 6], [7, 0, 8]])\nresult = eightPuzzle.solve()\nexpected = ['right']\nassertEqual(result, expected)\n"], "outputs": [], "test": "import unittest\n\nclass EightPuzzleTestFindBlank(unittest.TestCase):\n def test_find_blank_1(self):\n state = [[2, 3, 4], [5, 8, 1], [6, 0, 7]]\n eightPuzzle = EightPuzzle(state)\n self.assertEqual(eightPuzzle.find_blank(state), (2, 1))\n\n def test_find_blank_2(self):\n state = [[2, 3, 4], [5, 0, 1], [6, 8, 7]]\n eightPuzzle = EightPuzzle(state)\n self.assertEqual(eightPuzzle.find_blank(state), (1, 1))\n\n def test_find_blank_3(self):\n state = [[2, 3, 4], [5, 8, 1], [6, 8, 7]]\n eightPuzzle = EightPuzzle(state)\n self.assertEqual(eightPuzzle.find_blank(state), None)\n\n def test_find_blank_4(self):\n state = [[2, 3, 4], [5, 8, 1], [6, 8, 7]]\n eightPuzzle = EightPuzzle(state)\n self.assertEqual(eightPuzzle.find_blank(state), None)\n\n def test_find_blank_5(self):\n state = [[2, 3, 4], [5, 8, 1], [6, 8, 7]]\n eightPuzzle = EightPuzzle(state)\n self.assertEqual(eightPuzzle.find_blank(state), None)\n\n\nclass EightPuzzleTestMove(unittest.TestCase):\n def setUp(self):\n self.initial_state = [[2, 3, 4], [5, 0, 1], [6, 8, 7]]\n self.eightPuzzle = EightPuzzle(self.initial_state)\n\n def test_move_1(self):\n result = self.eightPuzzle.move(self.initial_state, 'up')\n expected = [[2, 0, 4], [5, 3, 1], [6, 8, 7]]\n self.assertEqual(result, expected)\n\n def test_move_2(self):\n result = self.eightPuzzle.move(self.initial_state, 'down')\n expected = [[2, 3, 4], [5, 8, 1], [6, 0, 7]]\n self.assertEqual(result, expected)\n\n def test_move_3(self):\n result = self.eightPuzzle.move(self.initial_state, 'left')\n expected = [[2, 3, 4], [0, 5, 1], [6, 8, 7]]\n self.assertEqual(result, expected)\n\n def test_move_4(self):\n result = self.eightPuzzle.move(self.initial_state, 'right')\n expected = [[2, 3, 4], [5, 1, 0], [6, 8, 7]]\n self.assertEqual(result, expected)\n\n def test_move_5(self):\n result = self.eightPuzzle.move(self.initial_state, '???')\n expected = [[2, 3, 4], [5, 0, 1], [6, 8, 7]]\n self.assertEqual(result, expected)\n\n\nclass EightPuzzleTestGetPossibleMoves(unittest.TestCase):\n def test_get_possible_moves_1(self):\n eightPuzzle = EightPuzzle(None)\n state = [[2, 3, 4], [5, 0, 1], [6, 8, 7]]\n result = eightPuzzle.get_possible_moves(state)\n expected = ['up', 'down', 'left', 'right']\n for direction in result:\n self.assertIn(direction, expected)\n\n def test_get_possible_moves_2(self):\n eightPuzzle = EightPuzzle(None)\n state = [[2, 3, 4], [5, 8, 1], [6, 0, 7]]\n result = eightPuzzle.get_possible_moves(state)\n expected = ['up', 'left', 'right']\n for direction in result:\n self.assertIn(direction, expected)\n\n def test_get_possible_moves_3(self):\n eightPuzzle = EightPuzzle(None)\n state = [[2, 0, 4], [5, 3, 1], [6, 8, 7]]\n result = eightPuzzle.get_possible_moves(state)\n expected = ['down', 'left', 'right']\n for direction in result:\n self.assertIn(direction, expected)\n\n def test_get_possible_moves_4(self):\n eightPuzzle = EightPuzzle(None)\n state = [[2, 3, 4], [5, 1, 0], [6, 8, 7]]\n result = eightPuzzle.get_possible_moves(state)\n expected = ['up', 'down', 'left']\n for direction in result:\n self.assertIn(direction, expected)\n\n def test_get_possible_moves_5(self):\n eightPuzzle = EightPuzzle(None)\n state = [[2, 3, 4], [0, 5, 1], [6, 8, 7]]\n result = eightPuzzle.get_possible_moves(state)\n expected = ['up', 'down', 'right']\n for direction in result:\n self.assertIn(direction, expected)\n\n\nclass EightPuzzleTestSolve(unittest.TestCase):\n def test_solve_1(self):\n eightPuzzle = EightPuzzle([[1, 2, 3], [4, 5, 6], [7, 0, 8]])\n result = eightPuzzle.solve()\n expected = ['right']\n self.assertEqual(result, expected)\n\n def test_solve_2(self):\n eightPuzzle = EightPuzzle([[1, 2, 3], [4, 0, 6], [7, 5, 8]])\n result = eightPuzzle.solve()\n expected = ['down', 'right']\n self.assertEqual(result, expected)\n\n def test_solve_3(self):\n eightPuzzle = EightPuzzle([[1, 2, 3], [0, 4, 5], [6, 7, 8]])\n result = eightPuzzle.solve()\n expected = ['right', 'right', 'down', 'left', 'left', 'up', 'right', 'down', 'right', 'up', 'left', 'left', 'down', 'right', 'right']\n self.assertEqual(result, expected)\n\n def test_solve_4(self):\n eightPuzzle = EightPuzzle([[1, 2, 3], [4, 5, 6], [7, 8, 0]])\n result = eightPuzzle.solve()\n expected = []\n self.assertEqual(result, expected)\n\n def test_solve_5(self):\n eightPuzzle = EightPuzzle([[1, 2, 3], [4, 5, 6], [0, 7, 8]])\n result = eightPuzzle.solve()\n expected = ['right', 'right']\n self.assertEqual(result, expected)\n\n def test_solve_6(self):\n eightPuzzle = EightPuzzle([[0, 0, 0], [0, 0, 0], [0, 0, 0]])\n result = eightPuzzle.solve()\n expected = None\n self.assertEqual(result, expected)"} {"task_id": "DREval/111", "entry_point": "EncryptionUtils", "code": "class EncryptionUtils:\n def __init__(self, key):\n self.key = key\n\n def caesar_cipher(self, plaintext, shift):\n ciphertext = \"\"\n for char in plaintext:\n if char.isalpha():\n if char.isupper():\n ascii_offset = 65\n else:\n ascii_offset = 97\n shifted_char = chr((ord(char) - ascii_offset + shift) % 26 + ascii_offset)\n ciphertext += shifted_char\n else:\n ciphertext += char\n return ciphertext\n \n def vigenere_cipher(self, plain_text):\n encrypted_text = \"\"\n key_index = 0\n for char in plain_text:\n if char.isalpha():\n shift = ord(self.key[key_index % len(self.key)].lower()) - ord('a')\n encrypted_char = chr((ord(char.lower()) - ord('a') + shift) % 26 + ord('a'))\n encrypted_text += encrypted_char.upper() if char.isupper() else encrypted_char\n key_index += 1\n else:\n encrypted_text += char\n return encrypted_text\n\n def rail_fence_cipher(self, plain_text, rails):\n fence = [['\\n' for _ in range(len(plain_text))] for _ in range(rails)]\n direction = -1\n row, col = 0, 0\n\n for char in plain_text:\n if row == 0 or row == rails-1:\n direction = -direction\n\n fence[row][col] = char\n col += 1\n row += direction\n\n encrypted_text = ''\n for i in range(rails):\n for j in range(len(plain_text)):\n if fence[i][j] != '\\n':\n encrypted_text += fence[i][j]\n\n return encrypted_text", "inputs": ["encryption_utils = EncryptionUtils(\"key\")\nassertEqual(encryption_utils.caesar_cipher(\"abc\", 1), \"bcd\")\n", "encryption_utils = EncryptionUtils(\"key\")\nassertEqual(encryption_utils.vigenere_cipher(\"abc\"), \"kfa\")\n", "encryption_utils = EncryptionUtils(\"key\")\nassertEqual(encryption_utils.rail_fence_cipher(\"abc\", 2), \"acb\")\n", "encryption_utils = EncryptionUtils(\"key\")\nassertEqual(encryption_utils.caesar_cipher(\"abc\", 1), \"bcd\")\nassertEqual(encryption_utils.vigenere_cipher(\"abc\"), \"kfa\")\nassertEqual(encryption_utils.rail_fence_cipher(\"abc\", 2), \"acb\")\n"], "outputs": [], "test": "import unittest\n\n\nclass EncryptionUtilsTestCaesarCipher(unittest.TestCase):\n def test_caesar_cipher(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"abc\", 1), \"bcd\")\n\n def test_caesar_cipher_2(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"WORLD\", -2), \"UMPJB\")\n\n def test_caesar_cipher_3(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"\", 4), \"\")\n\n def test_caesar_cipher_4(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"abcxyz\", 26), \"abcxyz\")\n\n def test_caesar_cipher_5(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"abcxyz\", 27), \"bcdyza\")\n\n def test_caesar_cipher_6(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"123\", 27), \"123\")\n\n\nclass EncryptionUtilsTestVigenereCipher(unittest.TestCase):\n def test_vigenere_cipher(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.vigenere_cipher(\"abc\"), \"kfa\")\n\n def test_vigenere_cipher_2(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.vigenere_cipher(\"hello\"), \"rijvs\")\n\n def test_vigenere_cipher_3(self):\n encryption_utils = EncryptionUtils(\"longkey\")\n self.assertEqual(encryption_utils.vigenere_cipher(\"AbCdEfG\"), \"LpPjOjE\")\n\n def test_vigenere_cipher_4(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.vigenere_cipher(\"Hello, World! 123\"), \"Rijvs, Uyvjn! 123\")\n\n def test_vigenere_cipher_5(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.vigenere_cipher(\"\"), \"\")\n\n\nclass EncryptionUtilsTestRailFenceCipher(unittest.TestCase):\n def test_rail_fence_cipher(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"abc\", 2), \"acb\")\n\n def test_rail_fence_cipher_2(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"hello\", 2), \"hloel\")\n\n def test_rail_fence_cipher_3(self):\n encryption_utils = EncryptionUtils(\"longkey\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"AbCdEfG\", 2), \"ACEGbdf\")\n\n def test_rail_fence_cipher_4(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"Hello, World! 123\", 2), \"Hlo ol!13el,Wrd 2\")\n\n def test_rail_fence_cipher_5(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"\", 2), \"\")\n\n def test_rail_fence_cipher_6(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"abcdefg\", 3), \"aebdfcg\")\n\n\nclass EncryptionUtilsTestMain(unittest.TestCase):\n def test_main(self):\n encryption_utils = EncryptionUtils(\"key\")\n self.assertEqual(encryption_utils.caesar_cipher(\"abc\", 1), \"bcd\")\n self.assertEqual(encryption_utils.vigenere_cipher(\"abc\"), \"kfa\")\n self.assertEqual(encryption_utils.rail_fence_cipher(\"abc\", 2), \"acb\")"} {"task_id": "DREval/112", "entry_point": "ExpressionCalculator", "code": "import re\nfrom collections import deque\nfrom decimal import Decimal\n\n\nclass ExpressionCalculator:\n def __init__(self):\n self.postfix_stack = deque()\n self.operat_priority = [0, 3, 2, 1, -1, 1, 0, 2]\n\n def calculate(self, expression):\n self.prepare(self.transform(expression))\n\n result_stack = deque()\n self.postfix_stack.reverse()\n\n while self.postfix_stack:\n current_op = self.postfix_stack.pop()\n if not self.is_operator(current_op):\n current_op = current_op.replace(\"~\", \"-\")\n result_stack.append(current_op)\n else:\n second_value = result_stack.pop()\n first_value = result_stack.pop()\n\n first_value = first_value.replace(\"~\", \"-\")\n second_value = second_value.replace(\"~\", \"-\")\n\n temp_result = self._calculate(first_value, second_value, current_op)\n result_stack.append(str(temp_result))\n\n return float(eval(\"*\".join(result_stack)))\n\n def prepare(self, expression):\n op_stack = deque([','])\n arr = list(expression)\n current_index = 0\n count = 0\n\n for i, current_op in enumerate(arr):\n if self.is_operator(current_op):\n if count > 0:\n self.postfix_stack.append(\"\".join(arr[current_index: current_index + count]))\n peek_op = op_stack[-1]\n if current_op == ')':\n while op_stack[-1] != '(':\n self.postfix_stack.append(str(op_stack.pop()))\n op_stack.pop()\n else:\n while current_op != '(' and peek_op != ',' and self.compare(current_op, peek_op):\n self.postfix_stack.append(str(op_stack.pop()))\n peek_op = op_stack[-1]\n op_stack.append(current_op)\n\n count = 0\n current_index = i + 1\n else:\n count += 1\n\n if count > 1 or (count == 1 and not self.is_operator(arr[current_index])):\n self.postfix_stack.append(\"\".join(arr[current_index: current_index + count]))\n\n while op_stack[-1] != ',':\n self.postfix_stack.append(str(op_stack.pop()))\n\n @staticmethod\n def is_operator(c):\n return c in {'+', '-', '*', '/', '(', ')', '%'}\n\n def compare(self, cur, peek):\n if cur == '%':\n cur = '/'\n if peek == '%':\n peek = '/'\n return self.operat_priority[ord(peek) - 40] >= self.operat_priority[ord(cur) - 40]\n\n @staticmethod\n def _calculate(first_value, second_value, current_op):\n if current_op == '+':\n return Decimal(first_value) + Decimal(second_value)\n elif current_op == '-':\n return Decimal(first_value) - Decimal(second_value)\n elif current_op == '*':\n return Decimal(first_value) * Decimal(second_value)\n elif current_op == '/':\n return Decimal(first_value) / Decimal(second_value)\n elif current_op == '%':\n return Decimal(first_value) % Decimal(second_value)\n else:\n raise ValueError(\"Unexpected operator: {}\".format(current_op))\n\n @staticmethod\n def transform(expression):\n expression = re.sub(r\"\\s+\", \"\", expression)\n expression = re.sub(r\"=$\", \"\", expression)\n arr = list(expression)\n\n for i, c in enumerate(arr):\n if c == '-':\n if i == 0:\n arr[i] = '~'\n else:\n prev_c = arr[i - 1]\n if prev_c in {'+', '-', '*', '/', '(', 'E', 'e'}:\n arr[i] = '~'\n\n if arr[0] == '~' and (len(arr) > 1 and arr[1] == '('):\n arr[0] = '-'\n return \"0\" + \"\".join(arr)\n else:\n return \"\".join(arr)", "inputs": ["result = self.expression_calculator.calculate(\"2 + 3 * 4\")\nassertEqual(result, 14.0)\n", "self.expression_calculator.prepare(\"2+3*4\")\nassertEqual(self.expression_calculator.postfix_stack, deque(['2', '3', '4', '*', '+']))\n", "assertTrue(self.expression_calculator.is_operator(\"+\"))\n", "result = self.expression_calculator.compare(\"+\", \"-\")\nassertTrue(result)\n", "result = self.expression_calculator._calculate(\"2\", \"3\", \"+\")\nassertEqual(result, Decimal(5.0))\n", "result = self.expression_calculator.transform(\"2 + 3 * 4\")\nassertEqual(result, \"2+3*4\")\n", "result = self.expression_calculator.calculate(\"2 + 3 * 4\")\nassertEqual(result, 14.0)\nself.expression_calculator.prepare(\"2+3*4\")\nassertEqual(self.expression_calculator.postfix_stack, deque(['2', '3', '4', '*', '+']))\nassertTrue(self.expression_calculator.is_operator(\"+\"))\nresult = self.expression_calculator.compare(\"+\", \"-\")\nassertTrue(result)\nresult = self.expression_calculator._calculate(\"2\", \"3\", \"+\")\nassertEqual(result, Decimal(5.0))\nresult = self.expression_calculator.transform(\"2 + 3 * 4\")\nassertEqual(result, \"2+3*4\")\n"], "outputs": [], "test": "import unittest\n\n\nclass ExpressionCalculatorTestCalculate(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_calculate_1(self):\n result = self.expression_calculator.calculate(\"2 + 3 * 4\")\n self.assertEqual(result, 14.0)\n\n def test_calculate_2(self):\n result = self.expression_calculator.calculate(\"2 + 3 + 4\")\n self.assertEqual(result, 9.0)\n\n def test_calculate_3(self):\n result = self.expression_calculator.calculate(\"2 * 3 * 4\")\n self.assertEqual(result, 24.0)\n\n def test_calculate_4(self):\n result = self.expression_calculator.calculate(\"2 + 4 / 4\")\n self.assertEqual(result, 3.0)\n\n def test_calculate_5(self):\n result = self.expression_calculator.calculate(\"(2 + 3) * 4\")\n self.assertEqual(result, 20.0)\n\n\nclass ExpressionCalculatorTestPrepare(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_prepare_1(self):\n self.expression_calculator.prepare(\"2+3*4\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque(['2', '3', '4', '*', '+']))\n\n def test_prepare_2(self):\n self.expression_calculator.prepare(\"2+3/4\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque(['2', '3', '4', '/', '+']))\n\n def test_prepare_3(self):\n self.expression_calculator.prepare(\"2-3*4\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque(['2', '3', '4', '*', '-']))\n\n def test_prepare_4(self):\n self.expression_calculator.prepare(\"1+3*4\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque(['1', '3', '4', '*', '+']))\n\n def test_prepare_5(self):\n self.expression_calculator.prepare(\"(2+3)*4\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque(['2', '3', '+', '4', '*']))\n\n def test_prepare_6(self):\n self.expression_calculator.prepare(\"\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque([]))\n\n\nclass ExpressionCalculatorTestIsOperator(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_is_operator_1(self):\n self.assertTrue(self.expression_calculator.is_operator(\"+\"))\n\n def test_is_operator_2(self):\n self.assertTrue(self.expression_calculator.is_operator(\"-\"))\n\n def test_is_operator_3(self):\n self.assertTrue(self.expression_calculator.is_operator(\"*\"))\n\n def test_is_operator_4(self):\n self.assertTrue(self.expression_calculator.is_operator(\"/\"))\n\n def test_is_operator_5(self):\n self.assertFalse(self.expression_calculator.is_operator(\"5\"))\n\n\nclass ExpressionCalculatorTestCompare(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_compare_1(self):\n result = self.expression_calculator.compare(\"+\", \"-\")\n self.assertTrue(result)\n\n def test_compare_2(self):\n result = self.expression_calculator.compare(\"*\", \"/\")\n self.assertTrue(result)\n\n def test_compare_3(self):\n result = self.expression_calculator.compare(\"+\", \"*\")\n self.assertTrue(result)\n\n def test_compare_4(self):\n result = self.expression_calculator.compare(\"*\", \"+\")\n self.assertFalse(result)\n\n def test_compare_5(self):\n result = self.expression_calculator.compare(\"/\", \"+\")\n self.assertFalse(result)\n\n def test_compare_6(self):\n result = self.expression_calculator.compare(\"%\", \"+\")\n self.assertFalse(result)\n\n def test_compare_7(self):\n result = self.expression_calculator.compare(\"+\", \"%\")\n self.assertTrue(result)\n\n\nclass ExpressionCalculatorTestCalculateMethod(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_calculate_method_1(self):\n result = self.expression_calculator._calculate(\"2\", \"3\", \"+\")\n self.assertEqual(result, Decimal(5.0))\n\n def test_calculate_method_2(self):\n result = self.expression_calculator._calculate(\"3\", \"2\", \"-\")\n self.assertEqual(result, Decimal(1.0))\n\n def test_calculate_method_3(self):\n result = self.expression_calculator._calculate(\"2\", \"3\", \"*\")\n self.assertEqual(result, Decimal(6.0))\n\n def test_calculate_method_4(self):\n result = self.expression_calculator._calculate(\"3\", \"3\", \"/\")\n self.assertEqual(result, Decimal(1.0))\n\n def test_calculate_method_5(self):\n result = self.expression_calculator._calculate(\"6\", \"2\", \"/\")\n self.assertEqual(result, Decimal(3.0))\n\n def test_calculate_method_6(self):\n result = self.expression_calculator._calculate(\"6\", \"2\", \"%\")\n self.assertEqual(result, Decimal(0.0))\n\n def test_calculate_method_7(self):\n try:\n self.expression_calculator._calculate(\"6\", \"2\", \"??\")\n except:\n pass\n\n\nclass ExpressionCalculatorTestTransform(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_transform_1(self):\n result = self.expression_calculator.transform(\"2 + 3 * 4\")\n self.assertEqual(result, \"2+3*4\")\n\n def test_transform_2(self):\n result = self.expression_calculator.transform(\"2 + 3 / 4\")\n self.assertEqual(result, \"2+3/4\")\n\n def test_transform_3(self):\n result = self.expression_calculator.transform(\"2 - 3 * 4\")\n self.assertEqual(result, \"2-3*4\")\n\n def test_transform_4(self):\n result = self.expression_calculator.transform(\"1 + 3 * 4\")\n self.assertEqual(result, \"1+3*4\")\n\n def test_transform_5(self):\n result = self.expression_calculator.transform(\"-2 + (-3) * 4\")\n self.assertEqual(result, \"~2+(~3)*4\")\n\n def test_transform_6(self):\n result = self.expression_calculator.transform(\"~(1 + 1)\")\n self.assertEqual(result, \"0-(1+1)\")\n\n\nclass ExpressionCalculatorTest(unittest.TestCase):\n def setUp(self):\n self.expression_calculator = ExpressionCalculator()\n\n def test_ExpressionCalculator(self):\n result = self.expression_calculator.calculate(\"2 + 3 * 4\")\n self.assertEqual(result, 14.0)\n\n self.expression_calculator.prepare(\"2+3*4\")\n self.assertEqual(self.expression_calculator.postfix_stack, deque(['2', '3', '4', '*', '+']))\n\n self.assertTrue(self.expression_calculator.is_operator(\"+\"))\n\n result = self.expression_calculator.compare(\"+\", \"-\")\n self.assertTrue(result)\n\n result = self.expression_calculator._calculate(\"2\", \"3\", \"+\")\n self.assertEqual(result, Decimal(5.0))\n\n result = self.expression_calculator.transform(\"2 + 3 * 4\")\n self.assertEqual(result, \"2+3*4\")"} {"task_id": "DREval/113", "entry_point": "FitnessTracker", "code": "class FitnessTracker:\n def __init__(self, height, weight, age, sex) -> None:\n self.height = height\n self.weight = weight\n self.age = age\n self.sex = sex\n self.BMI_std = [\n {\"male\": [20, 25]},\n {\"female\": [19, 24]}\n ]\n\n def get_BMI(self):\n return self.weight / self.height ** 2\n\n def condition_judge(self):\n BMI = self.get_BMI()\n if self.sex == \"male\":\n BMI_range = self.BMI_std[0][\"male\"]\n else:\n BMI_range = self.BMI_std[1][\"female\"]\n if BMI > BMI_range[1]:\n # too fat\n return 1\n elif BMI < BMI_range[0]:\n # too thin\n return -1\n else:\n # normal\n return 0\n\n def calculate_calorie_intake(self):\n if self.sex == \"male\":\n BMR = 10 * self.weight + 6.25 * self.height - 5 * self.age + 5\n else:\n BMR = 10 * self.weight + 6.25 * self.height - 5 * self.age - 161\n if self.condition_judge() == 1:\n calorie_intake = BMR * 1.2 # Sedentary lifestyle\n elif self.condition_judge() == -1:\n calorie_intake = BMR * 1.6 # Active lifestyle\n else:\n calorie_intake = BMR * 1.4 # Moderate lifestyle\n return calorie_intake", "inputs": ["fitnessTracker = FitnessTracker(1.8, 70, 20, \"male\")\nassertEqual(fitnessTracker.get_BMI(), 21.604938271604937)\n", "fitnessTracker = FitnessTracker(1.8, 45, 20, \"female\")\nassertEqual(fitnessTracker.condition_judge(), -1)\n", "fitnessTracker = FitnessTracker(1.8, 70, 20, \"female\")\nassertEqual(fitnessTracker.calculate_calorie_intake(), 630.3499999999999)\n", "fitnessTracker = FitnessTracker(1.8, 70, 20, \"male\")\nassertEqual(fitnessTracker.get_BMI(), 21.604938271604937)\nassertEqual(fitnessTracker.condition_judge(), 0)\nassertEqual(fitnessTracker.calculate_calorie_intake(), 862.75)\n"], "outputs": [], "test": "import unittest\n\n\nclass FitnessTrackerTestGetBMI(unittest.TestCase):\n def test_get_BMI(self):\n fitnessTracker = FitnessTracker(1.8, 70, 20, \"male\")\n self.assertEqual(fitnessTracker.get_BMI(), 21.604938271604937)\n\n def test_get_BMI_2(self):\n fitnessTracker = FitnessTracker(1.8, 50, 20, \"male\")\n self.assertEqual(fitnessTracker.get_BMI(), 15.432098765432098)\n\n def test_get_BMI_3(self):\n fitnessTracker = FitnessTracker(1.72, 53, 20, \"male\")\n self.assertEqual(fitnessTracker.get_BMI(), 17.915089237425637)\n\n def test_get_BMI_4(self):\n fitnessTracker = FitnessTracker(1.72, 60, 20, \"male\")\n self.assertEqual(fitnessTracker.get_BMI(), 20.281233098972418)\n\n def test_get_BMI_5(self):\n fitnessTracker = FitnessTracker(1.72, 65, 20, \"male\")\n self.assertEqual(fitnessTracker.get_BMI(), 21.971335857220122)\n\n\nclass FitnessTrackerTestConditionJudge(unittest.TestCase):\n def test_condition_judge(self):\n fitnessTracker = FitnessTracker(1.8, 45, 20, \"female\")\n self.assertEqual(fitnessTracker.condition_judge(), -1)\n\n def test_condition_judge_2(self):\n fitnessTracker = FitnessTracker(1.72, 80, 22, \"female\")\n self.assertEqual(fitnessTracker.condition_judge(), 1)\n\n def test_condition_judge_3(self):\n fitnessTracker = FitnessTracker(1.72, 53, 22, \"male\")\n self.assertEqual(fitnessTracker.condition_judge(), -1)\n\n def test_condition_judge_4(self):\n fitnessTracker = FitnessTracker(1.72, 60, 22, \"male\")\n self.assertEqual(fitnessTracker.condition_judge(), 0)\n\n def test_condition_judge_5(self):\n fitnessTracker = FitnessTracker(1.72, 75, 22, \"male\")\n self.assertEqual(fitnessTracker.condition_judge(), 1)\n\n\nclass FitnessTrackerTestCaculateCalorieIntake(unittest.TestCase):\n def test_calculate_calorie_intake(self):\n fitnessTracker = FitnessTracker(1.8, 70, 20, \"female\")\n self.assertEqual(fitnessTracker.calculate_calorie_intake(), 630.3499999999999)\n\n def test_calculate_calorie_intake_2(self):\n fitnessTracker = FitnessTracker(1.72, 80, 22, \"female\")\n self.assertEqual(fitnessTracker.calculate_calorie_intake(), 647.6999999999999)\n\n def test_calculate_calorie_intake_3(self):\n fitnessTracker = FitnessTracker(1.72, 53, 22, \"male\")\n self.assertEqual(fitnessTracker.calculate_calorie_intake(), 697.2)\n\n def test_calculate_calorie_intake_4(self):\n fitnessTracker = FitnessTracker(1.72, 60, 22, \"male\")\n self.assertEqual(fitnessTracker.calculate_calorie_intake(), 708.05)\n\n def test_calculate_calorie_intake_5(self):\n fitnessTracker = FitnessTracker(1.72, 75, 22, \"male\")\n self.assertEqual(fitnessTracker.calculate_calorie_intake(), 786.9)\n\n\nclass FitnessTrackerTestMain(unittest.TestCase):\n def test_main(self):\n fitnessTracker = FitnessTracker(1.8, 70, 20, \"male\")\n self.assertEqual(fitnessTracker.get_BMI(), 21.604938271604937)\n self.assertEqual(fitnessTracker.condition_judge(), 0)\n self.assertEqual(fitnessTracker.calculate_calorie_intake(), 862.75)"} {"task_id": "DREval/114", "entry_point": "GomokuGame", "code": "class GomokuGame:\n def __init__(self, board_size):\n self.board_size = board_size\n self.board = [[' ' for _ in range(board_size)] for _ in range(board_size)]\n self.current_player = 'X'\n\n def make_move(self, row, col):\n if self.board[row][col] == ' ':\n self.board[row][col] = self.current_player\n self.current_player = 'O' if self.current_player == 'X' else 'X'\n return True\n return False\n\n def check_winner(self):\n directions = [(0, 1), (1, 0), (1, 1), (1, -1)]\n for row in range(self.board_size):\n for col in range(self.board_size):\n if self.board[row][col] != ' ':\n for direction in directions:\n if self._check_five_in_a_row(row, col, direction):\n return self.board[row][col]\n return None\n\n def _check_five_in_a_row(self, row, col, direction):\n dx, dy = direction\n count = 1\n symbol = self.board[row][col]\n for i in range(1, 5):\n new_row = row + dx * i\n new_col = col + dy * i\n if not (0 <= new_row < self.board_size and 0 <= new_col < self.board_size):\n return False\n if self.board[new_row][new_col] != symbol:\n return False\n count += 1\n return count == 5", "inputs": ["board = [[' ' for _ in range(self.board_size)] for _ in range(self.board_size)]\nassertEqual(True, self.gomokuGame.make_move(0, 0))\nboard[0][0] = 'X'\nassertEqual(board, self.gomokuGame.board)\n", "gomokuGame = GomokuGame(10)\nassertEqual(None, gomokuGame.check_winner())\n", "assertEqual(True, self.gomokuGame._check_five_in_a_row(5, 5, (0, -1)))\n", "gomokuGame = GomokuGame(10)\nmoves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 1)]\nassertEqual(None, gomokuGame.check_winner())\nfor move in moves:\n\tassertEqual(True, gomokuGame.make_move(move[0], move[1]))\nassertEqual(False, gomokuGame.make_move(0, 0))\nassertEqual(True, gomokuGame._check_five_in_a_row(5, 5, (0, -1)))\nassertEqual('X', gomokuGame.check_winner())\n"], "outputs": [], "test": "import unittest\n\nclass GomokuGameTestMakeMove(unittest.TestCase):\n def setUp(self) -> None:\n self.board_size = 10\n self.gomokuGame = GomokuGame(self.board_size)\n\n def test_make_move_1(self):\n board = [[' ' for _ in range(self.board_size)] for _ in range(self.board_size)]\n self.assertEqual(True, self.gomokuGame.make_move(0, 0))\n board[0][0] = 'X'\n self.assertEqual(board, self.gomokuGame.board)\n\n # same position\n def test_make_move_2(self):\n board = [[' ' for _ in range(self.board_size)] for _ in range(self.board_size)]\n self.assertEqual(True, self.gomokuGame.make_move(0, 0))\n self.assertEqual(False, self.gomokuGame.make_move(0, 0))\n board[0][0] = 'X'\n self.assertEqual(board, self.gomokuGame.board)\n\n def test_make_move_3(self):\n board = [[' ' for _ in range(self.board_size)] for _ in range(self.board_size)]\n self.assertEqual(True, self.gomokuGame.make_move(0, 0))\n self.assertEqual(True, self.gomokuGame.make_move(0, 1))\n board[0][0] = 'X'\n board[0][1] = 'O'\n self.assertEqual(board, self.gomokuGame.board)\n\n def test_make_move_4(self):\n board = [[' ' for _ in range(self.board_size)] for _ in range(self.board_size)]\n self.assertEqual(True, self.gomokuGame.make_move(0, 0))\n self.assertEqual(True, self.gomokuGame.make_move(0, 1))\n self.assertEqual(False, self.gomokuGame.make_move(0, 0))\n board[0][0] = 'X'\n board[0][1] = 'O'\n self.assertEqual(board, self.gomokuGame.board)\n\n def test_make_move_5(self):\n board = [[' ' for _ in range(self.board_size)] for _ in range(self.board_size)]\n self.assertEqual(True, self.gomokuGame.make_move(0, 0))\n self.assertEqual(True, self.gomokuGame.make_move(0, 1))\n self.assertEqual(False, self.gomokuGame.make_move(0, 1))\n board[0][0] = 'X'\n board[0][1] = 'O'\n self.assertEqual(board, self.gomokuGame.board)\n\n\nclass GomokuGameTestCheckWinner(unittest.TestCase):\n def test_check_winner_1(self):\n gomokuGame = GomokuGame(10)\n self.assertEqual(None, gomokuGame.check_winner())\n\n def test_check_winner_2(self):\n gomokuGame = GomokuGame(10)\n moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 1)]\n for move in moves:\n gomokuGame.make_move(move[0], move[1])\n self.assertEqual('X', gomokuGame.check_winner())\n\n def test_check_winner_3(self):\n gomokuGame = GomokuGame(10)\n moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 0), (0, 4)]\n for move in moves:\n gomokuGame.make_move(move[0], move[1])\n self.assertEqual('O', gomokuGame.check_winner())\n\n def test_check_winner_4(self):\n gomokuGame = GomokuGame(10)\n moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 1), (0, 4)]\n for move in moves:\n gomokuGame.make_move(move[0], move[1])\n self.assertEqual(gomokuGame.check_winner(), 'O')\n\n def test_check_winner_5(self):\n gomokuGame = GomokuGame(10)\n moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 1), (0, 4), (5, 0)]\n for move in moves:\n gomokuGame.make_move(move[0], move[1])\n self.assertEqual('O', gomokuGame.check_winner())\n\n\nclass GomokuGameTestCheckFiveInARow(unittest.TestCase):\n def setUp(self) -> None:\n self.gomokuGame = GomokuGame(10)\n moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 1)]\n for move in moves:\n self.gomokuGame.make_move(move[0], move[1])\n\n def test_check_five_in_a_row_1(self):\n self.assertEqual(True, self.gomokuGame._check_five_in_a_row(5, 5, (0, -1)))\n\n def test_check_five_in_a_row_2(self):\n self.assertEqual(True, self.gomokuGame._check_five_in_a_row(5, 1, (0, 1)))\n\n def test_check_five_in_a_row_3(self):\n self.assertEqual(False, self.gomokuGame._check_five_in_a_row(0, 0, (0, 1)))\n\n def test_check_five_in_a_row_4(self):\n self.assertEqual(False, self.gomokuGame._check_five_in_a_row(0, 0, (1, 0)))\n\n def test_check_five_in_a_row_5(self):\n self.assertEqual(False, self.gomokuGame._check_five_in_a_row(5, 5, (1, 0)))\n\nclass GomokuGameTestMain(unittest.TestCase):\n def test_main(self):\n gomokuGame = GomokuGame(10)\n moves = [(5, 5), (0, 0), (5, 4), (0, 1), (5, 3), (0, 2), (5, 2), (0, 3), (5, 1)]\n self.assertEqual(None, gomokuGame.check_winner())\n for move in moves:\n self.assertEqual(True, gomokuGame.make_move(move[0], move[1]))\n self.assertEqual(False, gomokuGame.make_move(0, 0))\n self.assertEqual(True, gomokuGame._check_five_in_a_row(5, 5, (0, -1)))\n self.assertEqual('X', gomokuGame.check_winner())"} {"task_id": "DREval/115", "entry_point": "Hotel", "code": "class Hotel:\n def __init__(self, name, rooms):\n self.name = name\n self.available_rooms = rooms\n # available_rooms = {room_type1: room_number1, room_type2: room_number2, ...}\n # available_rooms = {'single': 5, 'double': 3}\n self.booked_rooms = {}\n # booked_rooms = {room_type1: {name1: room_number1, name2: room_number2, ...}, room_type2: {...}, ...}\n # booked_rooms = {'single': {'name1': 2, 'name2':1}, 'double': {}}\n\n def book_room(self, room_type, room_number, name):\n # Check if there are any rooms of the specified type available\n if room_type not in self.available_rooms.keys():\n return False\n\n if room_number <= self.available_rooms[room_type]:\n # Book the room by adding it to the booked_rooms dictionary\n if room_type not in self.booked_rooms.keys():\n self.booked_rooms[room_type] = {}\n self.booked_rooms[room_type][name] = room_number\n self.available_rooms[room_type] -= room_number\n return \"Success!\"\n elif self.available_rooms[room_type] != 0:\n return self.available_rooms[room_type]\n else:\n return False\n\n def check_in(self, room_type, room_number, name):\n # Check if the room of the specified type and number is booked\n if room_type not in self.booked_rooms.keys():\n return False\n if name in self.booked_rooms[room_type]:\n if room_number > self.booked_rooms[room_type][name]:\n return False\n elif room_number == self.booked_rooms[room_type][name]:\n # Check in the room by removing it from the booked_rooms dictionary\n self.booked_rooms[room_type].pop(name)\n else:\n self.booked_rooms[room_type][name] -= room_number\n\n\n def check_out(self, room_type, room_number):\n if room_type in self.available_rooms:\n self.available_rooms[room_type] += room_number\n else:\n self.available_rooms[room_type] = room_number\n\n def get_available_rooms(self, room_type):\n return self.available_rooms[room_type]", "inputs": ["result = self.hotel.book_room('single', 2, 'guest 1')\nassertEqual(result, 'Success!')\nassertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}})\nassertEqual(self.hotel.available_rooms, {'single': 1, 'double': 2})\n", "self.hotel.check_in('single', 1, 'guest 1')\nassertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 1}, 'double': {'guest 2': 1}})\n", "self.hotel.check_out('single', 1)\nassertEqual(self.hotel.available_rooms, {'single': 4, 'double': 2})\nassertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n", "result = self.hotel.get_available_rooms('single')\nassertEqual(result, 3)\n", "result = self.hotel.book_room('single', 2, 'guest 1')\nassertEqual(result, 'Success!')\nassertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}})\nassertEqual(self.hotel.available_rooms, {'single': 1, 'double': 2})\nself.hotel.check_in('single', 2, 'guest 1')\nassertEqual(self.hotel.booked_rooms, {'single': {}})\nassertEqual(self.hotel.available_rooms, {'single': 1, 'double': 2})\nself.hotel.check_out('single', 2)\nassertEqual(self.hotel.available_rooms, {'single': 3, 'double': 2})\nassertEqual(self.hotel.get_available_rooms('single'), 3)\n"], "outputs": [], "test": "import unittest\n\n\nclass HotelTestBookRoom(unittest.TestCase):\n def setUp(self):\n self.hotel = Hotel('peace hotel', {'single': 3, 'double': 2})\n\n def test_book_room_1(self):\n result = self.hotel.book_room('single', 2, 'guest 1')\n self.assertEqual(result, 'Success!')\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}})\n self.assertEqual(self.hotel.available_rooms, {'single': 1, 'double': 2})\n\n def test_book_room_2(self):\n result = self.hotel.book_room('triple', 2, 'guest 1')\n self.assertFalse(result)\n self.assertEqual(self.hotel.booked_rooms, {})\n self.assertEqual(self.hotel.available_rooms, {'single': 3, 'double': 2})\n\n def test_book_room_3(self):\n self.hotel.book_room('single', 2, 'guest 1')\n result = self.hotel.book_room('single', 2, 'guest 2')\n self.assertEqual(result, 1)\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}})\n self.assertEqual(self.hotel.available_rooms, {'single': 1, 'double': 2})\n\n def test_book_room_4(self):\n self.hotel.book_room('single', 2, 'guest 1')\n result = self.hotel.book_room('single', 1, 'guest 2')\n self.assertEqual(result, 'Success!')\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2, 'guest 2': 1}})\n self.assertEqual(self.hotel.available_rooms, {'double': 2, 'single': 0})\n\n def test_book_room_5(self):\n self.hotel.book_room('single', 2, 'guest 1')\n result = self.hotel.book_room('single', 3, 'guest 2')\n self.assertEqual(result, 1)\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}})\n self.assertEqual(self.hotel.available_rooms, {'single': 1, 'double': 2})\n\n def test_book_room_6(self):\n self.hotel.book_room('single', 3, 'guest 1')\n result = self.hotel.book_room('single', 100, 'guest 1')\n self.assertFalse(result)\n\n\nclass HotelTestCheckIn(unittest.TestCase):\n def setUp(self):\n self.hotel = Hotel('Test Hotel', {'single': 3, 'double': 2})\n self.hotel.booked_rooms = {'single': {'guest 1': 2}, 'double': {'guest 2': 1}}\n\n def test_check_in_1(self):\n self.hotel.check_in('single', 1, 'guest 1')\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 1}, 'double': {'guest 2': 1}})\n\n def test_check_in_2(self):\n self.assertFalse(self.hotel.check_in('single', 3, 'guest 1'))\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n def test_check_in_3(self):\n self.assertFalse(self.hotel.check_in('double', 1, 'guest 1'))\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n def test_check_in_4(self):\n self.hotel.check_in('double', 1, 'guest 2')\n self.assertEqual(self.hotel.booked_rooms, {'double': {}, 'single': {'guest 1': 2}})\n\n def test_check_in_5(self):\n self.hotel.check_in('double', 2, 'guest 2')\n self.assertEqual(self.hotel.booked_rooms, {'double': {'guest 2': 1}, 'single': {'guest 1': 2}})\n\n def test_check_in_6(self):\n res = self.hotel.check_in('abc', 1, 'guest 1')\n self.assertFalse(res)\n\n\nclass HotelTestCheckOut(unittest.TestCase):\n def setUp(self):\n self.hotel = Hotel('Test Hotel', {'single': 3, 'double': 2})\n self.hotel.booked_rooms = {'single': {'guest 1': 2}, 'double': {'guest 2': 1}}\n\n def test_check_out_1(self):\n self.hotel.check_out('single', 1)\n self.assertEqual(self.hotel.available_rooms, {'single': 4, 'double': 2})\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n def test_check_out_2(self):\n self.hotel.check_out('single', 3)\n self.assertEqual(self.hotel.available_rooms, {'single': 6, 'double': 2})\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n def test_check_out_3(self):\n self.hotel.check_out('triple', 2)\n self.assertEqual(self.hotel.available_rooms, {'single': 3, 'double': 2, 'triple': 2})\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n def test_check_out_4(self):\n self.hotel.check_out('double', 1)\n self.assertEqual(self.hotel.available_rooms, {'single': 3, 'double': 3})\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n def test_check_out_5(self):\n self.hotel.check_out('double', 2)\n self.assertEqual(self.hotel.available_rooms, {'single': 3, 'double': 4})\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}, 'double': {'guest 2': 1}})\n\n\nclass HotelTestAvailableRooms(unittest.TestCase):\n def setUp(self):\n self.hotel = Hotel('Test Hotel', {'single': 3, 'double': 2, 'triple': 2})\n\n def test_get_available_rooms(self):\n result = self.hotel.get_available_rooms('single')\n self.assertEqual(result, 3)\n\n def test_get_available_rooms_2(self):\n self.hotel.book_room('single', 2, 'guest 1')\n result = self.hotel.get_available_rooms('single')\n self.assertEqual(result, 1)\n\n def test_get_available_rooms_3(self):\n self.hotel.book_room('single', 3, 'guest 1')\n result = self.hotel.get_available_rooms('single')\n self.assertEqual(result, 0)\n\n def test_get_available_rooms_4(self):\n self.hotel.book_room('single', 3, 'guest 1')\n result = self.hotel.get_available_rooms('double')\n self.assertEqual(result, 2)\n\n def test_get_available_rooms_5(self):\n self.hotel.book_room('single', 3, 'guest 1')\n result = self.hotel.get_available_rooms('triple')\n self.assertEqual(result, 2)\n\n\nclass HotelTestMain(unittest.TestCase):\n def setUp(self) -> None:\n self.hotel = Hotel('Test Hotel', {'single': 3, 'double': 2})\n\n def test_main(self):\n result = self.hotel.book_room('single', 2, 'guest 1')\n self.assertEqual(result, 'Success!')\n self.assertEqual(self.hotel.booked_rooms, {'single': {'guest 1': 2}})\n self.assertEqual(self.hotel.available_rooms, {'single': 1, 'double': 2})\n\n self.hotel.check_in('single', 2, 'guest 1')\n self.assertEqual(self.hotel.booked_rooms, {'single': {}})\n self.assertEqual(self.hotel.available_rooms, {'single': 1, 'double': 2})\n\n self.hotel.check_out('single', 2)\n self.assertEqual(self.hotel.available_rooms, {'single': 3, 'double': 2})\n\n self.assertEqual(self.hotel.get_available_rooms('single'), 3)"} {"task_id": "DREval/116", "entry_point": "HRManagementSystem", "code": "class HRManagementSystem:\n def __init__(self):\n self.employees = {}\n\n def add_employee(self, employee_id, name, position, department, salary):\n if employee_id in self.employees:\n return False\n else:\n self.employees[employee_id] = {\n 'name': name,\n 'position': position,\n 'department': department,\n 'salary': salary\n }\n return True\n\n def remove_employee(self, employee_id):\n if employee_id in self.employees:\n del self.employees[employee_id]\n return True\n else:\n return False\n\n def update_employee(self, employee_id: int, employee_info: dict):\n employee = self.get_employee(employee_id)\n if employee == False:\n return False\n else:\n for key, value in employee_info.items():\n if key not in employee:\n return False\n for key, value in employee_info.items():\n employee[key] = value\n return True\n\n def get_employee(self, employee_id):\n if employee_id in self.employees:\n return self.employees[employee_id]\n else:\n return False\n\n def list_employees(self):\n employee_data = {}\n if self.employees:\n for employee_id, employee_info in self.employees.items():\n employee_details = {}\n employee_details[\"employee_ID\"] = employee_id\n for key, value in employee_info.items():\n employee_details[key] = value\n employee_data[employee_id] = employee_details\n return employee_data", "inputs": ["hr_system = HRManagementSystem()\nassertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), True)\nassertEqual(hr_system.employees[1], {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000})\n", "hr_system = HRManagementSystem()\nhr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\nassertEqual(hr_system.remove_employee(1), True)\nassertEqual(hr_system.employees, {})\n", "hr_system = HRManagementSystem()\nhr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\nassertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), True)\nassertEqual(hr_system.employees[1], {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000})\n", "hr_system = HRManagementSystem()\nhr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\nassertEqual(hr_system.get_employee(1), {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})\n", "hr_system = HRManagementSystem()\nhr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\nassertEqual(hr_system.list_employees(), {1: {'employee_ID':1,'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n", "hr_system = HRManagementSystem()\nhr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000)\nhr_system.add_employee(2, \"Jane Smith\", \"Developer\", \"IT\", 4000)\nassertEqual(hr_system.list_employees(), {1: {'employee_ID': 1, 'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}, 2: {'employee_ID': 2, 'name': 'Jane Smith', 'position': 'Developer', 'department': 'IT', 'salary': 4000}})\nhr_system.remove_employee(2)\nassertEqual(hr_system.list_employees(), {1: {'employee_ID': 1, 'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}})\nassertEqual(hr_system.remove_employee(2), False)\nassertEqual(hr_system.update_employee(1, {'name': 'John Doe Jr.', 'salary': 5500}), True)\nassertEqual(hr_system.employees[1], {'name': 'John Doe Jr.', 'position': 'Manager', 'department': 'HR', 'salary': 5500})\nassertEqual(hr_system.update_employee(3, {'name': 'Invalid Employee'}), False)\nassertEqual(hr_system.get_employee(1), {'name': 'John Doe Jr.', 'position': 'Manager', 'department': 'HR', 'salary': 5500})\nassertEqual(hr_system.get_employee(2), False)\nassertEqual(hr_system.list_employees(), {1: {'employee_ID': 1, 'name': 'John Doe Jr.', 'position': 'Manager', 'department': 'HR', 'salary': 5500}})\n"], "outputs": [], "test": "import unittest\n\nclass HRManagementSystemTestAddEmployee(unittest.TestCase):\n def test_add_employee(self):\n hr_system = HRManagementSystem()\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.employees[1], {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000})\n\n def test_add_employee_2(self):\n hr_system = HRManagementSystem()\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), False)\n self.assertEqual(hr_system.employees[1], {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000})\n\n def test_add_employee_3(self):\n hr_system = HRManagementSystem()\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.add_employee(2, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.employees,{1: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}, 2: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}})\n\n def test_add_employee_4(self):\n hr_system = HRManagementSystem()\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.add_employee(2, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), False)\n self.assertEqual(hr_system.employees,{1: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}, 2: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}})\n\n def test_add_employee_5(self):\n hr_system = HRManagementSystem()\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.add_employee(2, \"John Doe\", \"Manager\", \"HR\", 5000), True)\n self.assertEqual(hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000), False)\n self.assertEqual(hr_system.add_employee(2, \"John Doe\", \"Manager\", \"HR\", 5000), False)\n self.assertEqual(hr_system.employees,{1: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}, 2: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}})\n\nclass HRManagementSystemTestRemoveEmployee(unittest.TestCase):\n def test_remove_employee(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.remove_employee(1), True)\n self.assertEqual(hr_system.employees, {})\n\n def test_remove_employee_2(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.remove_employee(1), True)\n self.assertEqual(hr_system.remove_employee(1), False)\n self.assertEqual(hr_system.employees, {})\n\n def test_remove_employee_3(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.remove_employee(1), True)\n self.assertEqual(hr_system.employees, {2: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n\n def test_remove_employee_4(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.remove_employee(1), True)\n self.assertEqual(hr_system.remove_employee(2), True)\n self.assertEqual(hr_system.employees, {})\n\n def test_remove_employee_5(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.remove_employee(1), True)\n self.assertEqual(hr_system.remove_employee(2), True)\n self.assertEqual(hr_system.remove_employee(1), False)\n self.assertEqual(hr_system.remove_employee(2), False)\n self.assertEqual(hr_system.employees, {})\n\nclass HRManagementSystemTestUpdateEmployee(unittest.TestCase):\n def test_update_employee(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), True)\n self.assertEqual(hr_system.employees[1], {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000})\n\n def test_update_employee_2(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {}\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), False)\n self.assertEqual(hr_system.employees, {})\n\n def test_update_employee_3(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.update_employee(2, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), False)\n self.assertEqual(hr_system.employees, {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n\n def test_update_employee_4(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), True)\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), True)\n self.assertEqual(hr_system.employees[1], {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000})\n\n def test_update_employee_5(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), True)\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), True)\n self.assertEqual(hr_system.update_employee(1, {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}), True)\n self.assertEqual(hr_system.employees[1], {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})\n\n def test_update_employee_6(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.update_employee(1, {'Name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 20000}), False)\n\n\nclass HRManagementSystemTestGetEmployee(unittest.TestCase):\n def test_get_employee(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.get_employee(1), {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})\n\n def test_get_employee_2(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {}\n self.assertEqual(hr_system.get_employee(1), False)\n\n def test_get_employee_3(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.get_employee(2), False)\n\n def test_get_employee_4(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.get_employee(1), {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})\n self.assertEqual(hr_system.get_employee(1), {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})\n\n def test_get_employee_5(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.get_employee(1), {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})\n self.assertEqual(hr_system.get_employee(2), {'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000})\n\nclass HRManagementSystemTestListEmployees(unittest.TestCase):\n def test_list_employees(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID':1,'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n\n def test_list_employees_2(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {}\n self.assertEqual(hr_system.list_employees(), {})\n\n def test_list_employees_3(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID':1,'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'employee_ID':2,'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n\n def test_list_employees_4(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID':1,'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'employee_ID':2,'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID':1,'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n\n def test_list_employees_5(self):\n hr_system = HRManagementSystem()\n hr_system.employees = {1: {'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}}\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID':1,'name': 'John', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}, 2: {'employee_ID':2,'name': 'Jane', 'position': 'Manager', 'department': 'Sales', 'salary': 100000}})\n hr_system.employees = {}\n self.assertEqual(hr_system.list_employees(), {})\nclass HRManagementSystemTestMain(unittest.TestCase):\n def test_main(self):\n hr_system = HRManagementSystem()\n hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000)\n hr_system.add_employee(2, \"Jane Smith\", \"Developer\", \"IT\", 4000)\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID': 1, 'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}, 2: {'employee_ID': 2, 'name': 'Jane Smith', 'position': 'Developer', 'department': 'IT', 'salary': 4000}})\n hr_system.remove_employee(2)\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID': 1, 'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}})\n self.assertEqual(hr_system.remove_employee(2), False)\n self.assertEqual(hr_system.update_employee(1, {'name': 'John Doe Jr.', 'salary': 5500}), True)\n self.assertEqual(hr_system.employees[1], {'name': 'John Doe Jr.', 'position': 'Manager', 'department': 'HR', 'salary': 5500})\n self.assertEqual(hr_system.update_employee(3, {'name': 'Invalid Employee'}), False)\n self.assertEqual(hr_system.get_employee(1), {'name': 'John Doe Jr.', 'position': 'Manager', 'department': 'HR', 'salary': 5500})\n self.assertEqual(hr_system.get_employee(2), False)\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID': 1, 'name': 'John Doe Jr.', 'position': 'Manager', 'department': 'HR', 'salary': 5500}})\n\n def test_main_2(self):\n hr_system = HRManagementSystem()\n self.assertEqual(hr_system.remove_employee(2), False)\n self.assertEqual(hr_system.update_employee(1, {'name': 'John Doe Jr.', 'salary': 5500}), False)\n hr_system.add_employee(1, \"John Doe\", \"Manager\", \"HR\", 5000)\n hr_system.add_employee(2, \"Jane Smith\", \"Developer\", \"IT\", 4000)\n self.assertEqual(hr_system.list_employees(), {\n 1: {'employee_ID': 1, 'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000},\n 2: {'employee_ID': 2, 'name': 'Jane Smith', 'position': 'Developer', 'department': 'IT', 'salary': 4000}})\n self.assertEqual(hr_system.remove_employee(2), True)\n self.assertEqual(hr_system.employees, {1: {'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}})\n self.assertEqual(hr_system.list_employees(), {1: {'employee_ID': 1, 'name': 'John Doe', 'position': 'Manager', 'department': 'HR', 'salary': 5000}})\n self.assertEqual(hr_system.update_employee(1, {'name': 'John Doe Jr.', 'salary': 5500}), True)\n self.assertEqual(hr_system.employees[1], {'name': 'John Doe Jr.', 'position': 'Manager', 'department': 'HR', 'salary': 5500})\n self.assertEqual(hr_system.get_employee(1), {'name': 'John Doe Jr.', 'position': 'Manager', 'department': 'HR', 'salary': 5500})\n self.assertEqual(hr_system.get_employee(2), False)"} {"task_id": "DREval/117", "entry_point": "HtmlUtil", "code": "import re\nimport string\nimport gensim\nfrom bs4 import BeautifulSoup\n\n\nclass HtmlUtil:\n\n def __init__(self):\n self.SPACE_MARK = '-SPACE-'\n self.JSON_MARK = '-JSON-'\n self.MARKUP_LANGUAGE_MARK = '-MARKUP_LANGUAGE-'\n self.URL_MARK = '-URL-'\n self.NUMBER_MARK = '-NUMBER-'\n self.TRACE_MARK = '-TRACE-'\n self.COMMAND_MARK = '-COMMAND-'\n self.COMMENT_MARK = '-COMMENT-'\n self.CODE_MARK = '-CODE-'\n\n @staticmethod\n def __format_line_feed(text):\n return re.sub(re.compile(r'\\n+'), '\\n', text)\n\n def format_line_html_text(self, html_text):\n if html_text is None or len(html_text) == 0:\n return ''\n soup = BeautifulSoup(html_text, 'lxml')\n\n code_tag = soup.find_all(name=['pre', 'blockquote'])\n for tag in code_tag:\n tag.string = self.CODE_MARK\n\n ul_ol_group = soup.find_all(name=['ul', 'ol'])\n for ul_ol_item in ul_ol_group:\n li_group = ul_ol_item.find_all('li')\n for li_item in li_group:\n li_item_text = li_item.get_text().strip()\n if len(li_item_text) == 0:\n continue\n if li_item_text[-1] in string.punctuation:\n li_item.string = '[{0}]{1}'.format('-', li_item_text)\n continue\n li_item.string = '[{0}]{1}.'.format('-', li_item_text)\n\n p_group = soup.find_all(name=['p'])\n for p_item in p_group:\n p_item_text = p_item.get_text().strip()\n if p_item_text:\n if p_item_text[-1] in string.punctuation:\n p_item.string = p_item_text\n continue\n next_sibling = p_item.find_next_sibling()\n if next_sibling and self.CODE_MARK in next_sibling.get_text():\n p_item.string = p_item_text + ':'\n continue\n p_item.string = p_item_text + '.'\n\n clean_text = gensim.utils.decode_htmlentities(soup.get_text())\n return self.__format_line_feed(clean_text)\n\n def extract_code_from_html_text(self, html_text):\n text_with_code_tag = self.format_line_html_text(html_text)\n\n if self.CODE_MARK not in text_with_code_tag:\n return []\n\n code_index_start = 0\n soup = BeautifulSoup(html_text, 'lxml')\n code_tag = soup.find_all(name=['pre', 'blockquote'])\n code_count = text_with_code_tag.count(self.CODE_MARK)\n code_list = []\n for code_index in range(code_index_start, code_index_start + code_count):\n code = code_tag[code_index].get_text()\n if code:\n code_list.append(code)\n return code_list", "inputs": ["assertEqual(HtmlUtil._HtmlUtil__format_line_feed('aaa\\n\\n\\n'), 'aaa\\n')\n", "htmlutil = HtmlUtil()\nres = htmlutil.format_line_html_text('''\n\n\n

Title

\n

This is a paragraph.

\n
print('Hello, world!')
\n

Another paragraph.

\n
for i in range(5):\nprint(i)
\n\n\n''')\nassertEqual(res, '''\nTitle\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\n", "htmlutil = HtmlUtil()\nres = htmlutil.extract_code_from_html_text('''\n\n\n

Title

\n

This is a paragraph.

\n
print('Hello, world!')
\n

Another paragraph.

\n
for i in range(5):\n                print(i)
\n\n\n''')\nassertEqual(res, [\"print('Hello, world!')\", 'for i in range(5):\\n print(i)'])\n", "htmlutil = HtmlUtil()\nres = htmlutil.format_line_html_text('''\n\n\n

Title

\n

This is a paragraph.

\n
print('Hello, world!')
\n

Another paragraph.

\n
for i in range(5):\nprint(i)
\n\n\n''')\nassertEqual(res, '''\nTitle\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\nres = htmlutil.extract_code_from_html_text('''\n\n\n

Title

\n

This is a paragraph.

\n
print('Hello, world!')
\n

Another paragraph.

\n
for i in range(5):\n                print(i)
\n\n\n''')\nassertEqual(res, [\"print('Hello, world!')\", 'for i in range(5):\\n print(i)'])\n"], "outputs": [], "test": "import unittest\nimport sys\n\nclass HtmlUtilTestFormatLineFeed(unittest.TestCase):\n def test_format_line_feed_1(self):\n self.assertEqual(HtmlUtil._HtmlUtil__format_line_feed('aaa\\n\\n\\n'), 'aaa\\n')\n\n def test_format_line_feed_2(self):\n self.assertEqual(HtmlUtil._HtmlUtil__format_line_feed('aaa\\n\\n\\n\\n'), 'aaa\\n')\n\n def test_format_line_feed_3(self):\n self.assertEqual(HtmlUtil._HtmlUtil__format_line_feed('aaa\\n\\n\\nbbb\\n\\n'), 'aaa\\nbbb\\n')\n\n def test_format_line_feed_4(self):\n self.assertEqual(HtmlUtil._HtmlUtil__format_line_feed('ccc\\n\\n\\n'), 'ccc\\n')\n\n def test_format_line_feed_5(self):\n self.assertEqual(HtmlUtil._HtmlUtil__format_line_feed(''), '')\n\n\nclass HtmlUtilTestFormatLineHtmlText(unittest.TestCase):\n def test_format_line_html_text_1(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''\n \n \n

Title

\n

This is a paragraph.

\n 
print('Hello, world!')
\n

Another paragraph.

\n 
for i in range(5):\n        print(i)
\n \n \n ''')\n self.assertEqual(res, '''\nTitle\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\n\n def test_format_line_html_text_2(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''\n \n \n

Title2

\n

This is a paragraph.

\n 
print('Hello, world!')
\n

Another paragraph.

\n 
for i in range(5):\n        print(i)
\n \n \n ''')\n self.assertEqual(res, '''\nTitle2\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\n\n def test_format_line_html_text_3(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''\n \n \n

Title3

\n

This is a paragraph.

\n 
print('Hello, world!')
\n

Another paragraph.

\n 
for i in range(5):\n        print(i)
\n \n \n ''')\n self.assertEqual(res, '''\nTitle3\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\n\n def test_format_line_html_text_4(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''\n \n \n

Title4

\n

This is a paragraph.

\n 
print('Hello, world!')
\n

Another paragraph.

\n 
for i in range(5):\n        print(i)
\n \n \n ''')\n self.assertEqual(res, '''\nTitle4\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\n\n def test_format_line_html_text_5(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''\n \n \n

Title5

\n

This is a paragraph.

\n 
print('Hello, world!')
\n

Another paragraph.

\n 
for i in range(5):\n        print(i)
\n \n \n ''')\n self.assertEqual(res, '''\nTitle5\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\n def test_format_line_html_text_6(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('')\n self.assertEqual(res, '')\n\n def test_format_line_html_text_7(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''
  • Item 1!
''')\n self.assertEqual(res, '''[-]Item 1!''')\n\n def test_format_line_html_text_8(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''
''')\n self.assertEqual(res, '')\n\n def test_format_line_html_text_9(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''

Some sentence here.

''')\n self.assertEqual(res, 'Some sentence here.')\n\n def test_format_line_html_text_10(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''

Some paragraph here

Code block''')\n self.assertEqual(res, '''Some paragraph here.Code block''')\n\n def test_format_line_html_text_11(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''

Some paragraph here

Some text here
''')\n self.assertEqual(res, '''Some paragraph here.Some text here''')\n\n def test_format_line_html_text_12(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''
  • Item 1
''')\n self.assertEqual(res, '''[-]Item 1.''')\n\n\nclass HtmlUtilTestExtractCodeFromHtmlText(unittest.TestCase):\n def test_extract_code_from_html_text_1(self):\n htmlutil = HtmlUtil()\n res = htmlutil.extract_code_from_html_text('''\n \n \n

Title

\n

This is a paragraph.

\n 
print('Hello, world!')
\n

Another paragraph.

\n 
for i in range(5):\n                print(i)
\n \n \n ''')\n self.assertEqual(res, [\"print('Hello, world!')\", 'for i in range(5):\\n print(i)'])\n\n def test_extract_code_from_html_text_2(self):\n htmlutil = HtmlUtil()\n res = htmlutil.extract_code_from_html_text('''\n \n \n

Title

\n

This is a paragraph.

\n 
print('Hello, world!')
\n

Another paragraph.

\n 
for i in range(4):\n                print(i)
\n \n \n ''')\n self.assertEqual(res, [\"print('Hello, world!')\", 'for i in range(4):\\n print(i)'])\n\n def test_extract_code_from_html_text_3(self):\n htmlutil = HtmlUtil()\n res = htmlutil.extract_code_from_html_text('''\n \n \n

Title

\n

This is a paragraph.

\n 
print('Hello, world!')
\n

Another paragraph.

\n 
for i in range(3):\n                print(i)
\n \n \n ''')\n self.assertEqual(res, [\"print('Hello, world!')\", 'for i in range(3):\\n print(i)'])\n\n def test_extract_code_from_html_text_4(self):\n htmlutil = HtmlUtil()\n res = htmlutil.extract_code_from_html_text('''\n \n \n

Title

\n

This is a paragraph.

\n 
print('Hello, world!')
\n

Another paragraph.

\n 
for i in range(2):\n                print(i)
\n \n \n ''')\n self.assertEqual(res, [\"print('Hello, world!')\", 'for i in range(2):\\n print(i)'])\n\n def test_extract_code_from_html_text_5(self):\n htmlutil = HtmlUtil()\n htmlutil.CODE_MARK = 'abcdefg'\n res = htmlutil.extract_code_from_html_text(\"\")\n self.assertEqual(res, [])\n\n\nclass HtmlUtilTest(unittest.TestCase):\n def test_htmlutil(self):\n htmlutil = HtmlUtil()\n res = htmlutil.format_line_html_text('''\n \n \n

Title

\n

This is a paragraph.

\n 
print('Hello, world!')
\n

Another paragraph.

\n 
for i in range(5):\n        print(i)
\n \n \n ''')\n self.assertEqual(res, '''\nTitle\nThis is a paragraph.\n-CODE-\nAnother paragraph.\n-CODE-\n''')\n res = htmlutil.extract_code_from_html_text('''\n \n \n

Title

\n

This is a paragraph.

\n 
print('Hello, world!')
\n

Another paragraph.

\n 
for i in range(5):\n                print(i)
\n \n \n ''')\n self.assertEqual(res, [\"print('Hello, world!')\", 'for i in range(5):\\n print(i)'])\n\nif __name__ == '__main__':\n unittest.main()"} {"task_id": "DREval/118", "entry_point": "Interpolation", "code": "class Interpolation:\n def __init__(self):\n pass\n\n @staticmethod\n def interpolate_1d(x, y, x_interp):\n y_interp = []\n for xi in x_interp:\n for i in range(len(x) - 1):\n if x[i] <= xi <= x[i+1]:\n yi = y[i] + (y[i+1] - y[i]) * (xi - x[i]) / (x[i+1] - x[i])\n y_interp.append(yi)\n break\n return y_interp\n \n @staticmethod\n def interpolate_2d(x, y, z, x_interp, y_interp):\n z_interp = []\n for xi, yi in zip(x_interp, y_interp):\n for i in range(len(x) - 1):\n if x[i] <= xi <= x[i+1]:\n for j in range(len(y) - 1):\n if y[j] <= yi <= y[j+1]:\n z00 = z[i][j]\n z01 = z[i][j+1]\n z10 = z[i+1][j]\n z11 = z[i+1][j+1]\n zi = (z00 * (x[i+1] - xi) * (y[j+1] - yi) +\n z10 * (xi - x[i]) * (y[j+1] - yi) +\n z01 * (x[i+1] - xi) * (yi - y[j]) +\n z11 * (xi - x[i]) * (yi - y[j])) / ((x[i+1] - x[i]) * (y[j+1] - y[j]))\n z_interp.append(zi)\n break\n break\n return z_interp", "inputs": ["interpolation = Interpolation()\nassertEqual(interpolation.interpolate_1d([1, 2, 3], [1, 2, 3], [1.5, 2.5]), [1.5, 2.5])\n", "interpolation = Interpolation()\nassertEqual(\ninterpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [1.5, 2.5],\n[1.5, 2.5]), [3.0, 7.0])\n", "interpolation = Interpolation()\nassertEqual(interpolation.interpolate_1d([1, 2, 3], [1, 2, 3], [1.5, 2.5]), [1.5, 2.5])\nassertEqual(\ninterpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [1.5, 2.5],\n[1.5, 2.5]), [3.0, 7.0])\n"], "outputs": [], "test": "import unittest\n\n\nclass InterpolationTestInterpolate1d(unittest.TestCase):\n def test_interpolate_1d(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 2, 3], [1, 2, 3], [1.5, 2.5]), [1.5, 2.5])\n\n def test_interpolate_1d_2(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 6, 4], [1, 2, 5], [1.5, 2.5]), [1.1, 1.3])\n\n def test_interpolate_1d_3(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 6, 4], [1, 7, 5], [1.5, 2.5]), [1.6, 2.8])\n\n def test_interpolate_1d_4(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 6, 4], [1, 2, 5], [2, 3]), [1.2, 1.4])\n\n def test_interpolate_1d_5(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 6, 4], [1, 7, 5], [2, 3]), [2.2, 3.4])\n\n def test_interpolate_1d_6(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 6, 4], [1, 7, 5], []), [])\n\n def test_interpolate_1d_7(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([], [], [[], []]), [])\n\n\nclass InterpolationTestInterpolate2d(unittest.TestCase):\n def test_interpolate_2d(self):\n interpolation = Interpolation()\n self.assertEqual(\n interpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [1.5, 2.5],\n [1.5, 2.5]), [3.0, 7.0])\n\n def test_interpolate_2d_2(self):\n interpolation = Interpolation()\n self.assertEqual(\n interpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [1.5, 2.5], [3, 4]),\n [4.5])\n\n def test_interpolate_2d_3(self):\n interpolation = Interpolation()\n self.assertEqual(\n interpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [3, 4], [1.5, 2.5]),\n [7.5])\n\n def test_interpolate_2d_4(self):\n interpolation = Interpolation()\n self.assertEqual(\n interpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [3, 4], [3, 4]),\n [9.0])\n\n def test_interpolate_2d_5(self):\n interpolation = Interpolation()\n self.assertEqual(\n interpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [1.5, 2.5],\n [1.5, 2.5]), [3.0, 7.0])\n\n\nclass InterpolationTestMain(unittest.TestCase):\n def test_main(self):\n interpolation = Interpolation()\n self.assertEqual(interpolation.interpolate_1d([1, 2, 3], [1, 2, 3], [1.5, 2.5]), [1.5, 2.5])\n self.assertEqual(\n interpolation.interpolate_2d([1, 2, 3], [1, 2, 3], [[1, 2, 3], [4, 5, 6], [7, 8, 9]], [1.5, 2.5],\n [1.5, 2.5]), [3.0, 7.0])"} {"task_id": "DREval/119", "entry_point": "IPAddress", "code": "class IPAddress:\n def __init__(self, ip_address):\n self.ip_address = ip_address\n\n def is_valid(self):\n octets = self.ip_address.split('.')\n if len(octets) != 4:\n return False\n for octet in octets:\n if not octet.isdigit() or int(octet) < 0 or int(octet) > 255:\n return False\n return True\n\n def get_octets(self):\n if self.is_valid():\n return self.ip_address.split('.')\n else:\n return []\n\n def get_binary(self):\n if self.is_valid():\n binary_octets = []\n for octet in self.get_octets():\n binary_octets.append(format(int(octet), '08b'))\n return '.'.join(binary_octets)\n else:\n return ''", "inputs": ["ipaddress = IPAddress(\"10.10.10.10\")\nassertEqual(ipaddress.is_valid(), True)\n", "ipaddress = IPAddress(\"10.10.10.10\")\nassertEqual(ipaddress.get_octets(), [\"10\", \"10\", \"10\", \"10\"])\n", "ipaddress = IPAddress(\"10.10.10.10\")\nassertEqual(ipaddress.get_binary(), \"00001010.00001010.00001010.00001010\")\n", "ipaddress = IPAddress(\"10.10.10.10\")\nassertEqual(ipaddress.is_valid(), True)\nassertEqual(ipaddress.get_octets(), [\"10\", \"10\", \"10\", \"10\"])\nassertEqual(ipaddress.get_binary(), \"00001010.00001010.00001010.00001010\")\n"], "outputs": [], "test": "import unittest\n\n\nclass IPAddressTestIsValid(unittest.TestCase):\n def test_is_valid_1(self):\n ipaddress = IPAddress(\"10.10.10.10\")\n self.assertEqual(ipaddress.is_valid(), True)\n\n def test_is_valid_2(self):\n ipaddress = IPAddress(\"-1.10.10.10\")\n self.assertEqual(ipaddress.is_valid(), False)\n\n def test_is_valid_3(self):\n ipaddress = IPAddress(\"10.10.10\")\n self.assertEqual(ipaddress.is_valid(), False)\n\n def test_is_valid_4(self):\n ipaddress = IPAddress(\"a.10.10.10\")\n self.assertEqual(ipaddress.is_valid(), False)\n\n def test_is_valid_5(self):\n ipaddress = IPAddress(\"300.10.10.10\")\n self.assertEqual(ipaddress.is_valid(), False)\n\n\nclass IPAddressTestGetOctets(unittest.TestCase):\n def test_get_octets_1(self):\n ipaddress = IPAddress(\"10.10.10.10\")\n self.assertEqual(ipaddress.get_octets(), [\"10\", \"10\", \"10\", \"10\"])\n\n def test_get_octets_2(self):\n ipaddress = IPAddress(\"a.10.10.10\")\n self.assertEqual(ipaddress.get_octets(), [])\n\n def test_get_octets_3(self):\n ipaddress = IPAddress(\"-1.10.10.10\")\n self.assertEqual(ipaddress.get_octets(), [])\n\n def test_get_octets_4(self):\n ipaddress = IPAddress(\"300.10.10.10\")\n self.assertEqual(ipaddress.get_octets(), [])\n\n def test_get_octets_5(self):\n ipaddress = IPAddress(\".10.10.10\")\n self.assertEqual(ipaddress.get_octets(), [])\n\n\nclass IPAddressTestGetBinary(unittest.TestCase):\n def test_get_binary_1(self):\n ipaddress = IPAddress(\"10.10.10.10\")\n self.assertEqual(ipaddress.get_binary(), \"00001010.00001010.00001010.00001010\")\n\n def test_get_binary_2(self):\n ipaddress = IPAddress(\"a.10.10.10\")\n self.assertEqual(ipaddress.get_binary(), '')\n\n def test_get_binary_3(self):\n ipaddress = IPAddress(\"-1.10.10.10\")\n self.assertEqual(ipaddress.get_binary(), '')\n\n def test_get_binary_4(self):\n ipaddress = IPAddress(\"300.10.10.10\")\n self.assertEqual(ipaddress.get_binary(), '')\n\n def test_get_binary_5(self):\n ipaddress = IPAddress(\".10.10.10\")\n self.assertEqual(ipaddress.get_binary(), '')\n\n\nclass IPAddressTest(unittest.TestCase):\n def test_IPAddress(self):\n ipaddress = IPAddress(\"10.10.10.10\")\n self.assertEqual(ipaddress.is_valid(), True)\n self.assertEqual(ipaddress.get_octets(), [\"10\", \"10\", \"10\", \"10\"])\n self.assertEqual(ipaddress.get_binary(), \"00001010.00001010.00001010.00001010\")"} {"task_id": "DREval/120", "entry_point": "IpUtil", "code": "import socket\n\n\nclass IpUtil:\n\n @staticmethod\n def is_valid_ipv4(ip_address):\n try:\n socket.inet_pton(socket.AF_INET, ip_address)\n return True\n except socket.error:\n return False\n\n @staticmethod\n def is_valid_ipv6(ip_address):\n try:\n socket.inet_pton(socket.AF_INET6, ip_address)\n return True\n except socket.error:\n return False\n\n @staticmethod\n def get_hostname(ip_address):\n try:\n hostname = socket.gethostbyaddr(ip_address)[0]\n return hostname\n except socket.herror:\n return None", "inputs": ["result = IpUtil.is_valid_ipv4('192.168.0.123')\nassertEqual(result, True)\n", "result = IpUtil.is_valid_ipv6('2001:0db8:85a3:0000:0000:8a2e:0370:7334')\nassertEqual(result, True)\n", "result = IpUtil.get_hostname('110.242.68.3')\nassertEqual(result, None)\n", "result = IpUtil.is_valid_ipv4('192.168.0.123')\nassertEqual(result, True)\nresult = IpUtil.is_valid_ipv6('2001:0db8:85a3:0000:0000:8a2e:0370:7334')\nassertEqual(result, True)\nresult = IpUtil.get_hostname('110.242.68.3')\nassertEqual(result, None)\n"], "outputs": [], "test": "import unittest\n\n\nclass IpUtilTestIsValidIpv4(unittest.TestCase):\n def test_is_valid_ipv4_1(self):\n result = IpUtil.is_valid_ipv4('192.168.0.123')\n self.assertEqual(result, True)\n\n def test_is_valid_ipv4_2(self):\n result = IpUtil.is_valid_ipv4('10.10.10.10')\n self.assertEqual(result, True)\n\n def test_is_valid_ipv4_3(self):\n result = IpUtil.is_valid_ipv4('0.0.0.0')\n self.assertEqual(result, True)\n\n def test_is_valid_ipv4_4(self):\n result = IpUtil.is_valid_ipv4('abc.168.0.123')\n self.assertEqual(result, False)\n\n def test_is_valid_ipv4_5(self):\n result = IpUtil.is_valid_ipv4('256.0.0.0')\n self.assertEqual(result, False)\n\n\nclass IpUtilTestIsValidIpv6(unittest.TestCase):\n def test_is_valid_ipv6_1(self):\n result = IpUtil.is_valid_ipv6('2001:0db8:85a3:0000:0000:8a2e:0370:7334')\n self.assertEqual(result, True)\n\n def test_is_valid_ipv6_2(self):\n result = IpUtil.is_valid_ipv6('2001:0db8:85a3:::8a2e:0370:7334')\n self.assertEqual(result, False)\n\n def test_is_valid_ipv6_3(self):\n result = IpUtil.is_valid_ipv6('2001:0db8:85a3:2001:llll:8a2e:0370:7334')\n self.assertEqual(result, False)\n\n def test_is_valid_ipv6_4(self):\n result = IpUtil.is_valid_ipv6('2001:0db8:85a3:llll:llll:8a2e:0370:7334')\n self.assertEqual(result, False)\n\n def test_is_valid_ipv6_5(self):\n result = IpUtil.is_valid_ipv6('2001:0db8:85a3::llll:8a2e:0370:7334')\n self.assertEqual(result, False)\n\n\nclass IpUtilTestGetHostname(unittest.TestCase):\n def test_get_hostname_1(self):\n result = IpUtil.get_hostname('110.242.68.3')\n self.assertEqual(result, None)\n\n def test_get_hostname_2(self):\n result = IpUtil.get_hostname('10.0.0.1')\n self.assertEqual(result, None)\n\n def test_get_hostname_3(self):\n result = IpUtil.get_hostname('0.0.0.0')\n self.assertEqual(result, 'LAPTOP-2CS86KUM')\n\n def test_get_hostname_4(self):\n result = IpUtil.get_hostname('0.0.0.1')\n self.assertEqual(result, None)\n\n def test_get_hostname_5(self):\n result = IpUtil.get_hostname('0.0.0.2')\n self.assertEqual(result, None)\n\n\nclass IpUtilTest(unittest.TestCase):\n def test_IpUtil(self):\n result = IpUtil.is_valid_ipv4('192.168.0.123')\n self.assertEqual(result, True)\n\n result = IpUtil.is_valid_ipv6('2001:0db8:85a3:0000:0000:8a2e:0370:7334')\n self.assertEqual(result, True)\n\n result = IpUtil.get_hostname('110.242.68.3')\n self.assertEqual(result, None)"} {"task_id": "DREval/121", "entry_point": "JobMarketplace", "code": "class JobMarketplace:\n def __init__(self):\n self.job_listings = []\n self.resumes = []\n\n def post_job(self, job_title, company, requirements):\n # requirements = ['requirement1', 'requirement2']\n job = {\"job_title\": job_title, \"company\": company, \"requirements\": requirements}\n self.job_listings.append(job)\n\n def remove_job(self, job):\n self.job_listings.remove(job)\n\n def submit_resume(self, name, skills, experience):\n resume = {\"name\": name, \"skills\": skills, \"experience\": experience}\n self.resumes.append(resume)\n\n def withdraw_resume(self, resume):\n self.resumes.remove(resume)\n\n def search_jobs(self, criteria):\n matching_jobs = []\n for job_listing in self.job_listings:\n if criteria.lower() in job_listing[\"job_title\"].lower() or criteria.lower() in [r.lower() for r in job_listing[\"requirements\"]]:\n matching_jobs.append(job_listing)\n return matching_jobs\n\n def get_job_applicants(self, job):\n applicants = []\n for resume in self.resumes:\n if self.matches_requirements(resume, job[\"requirements\"]):\n applicants.append(resume)\n return applicants\n\n @staticmethod\n def matches_requirements(resume, requirements):\n for skill in resume[\"skills\"]:\n if skill not in requirements:\n return False\n return True", "inputs": ["jobMarketplace = JobMarketplace()\njobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\nassertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}])\n", "jobMarketplace = JobMarketplace()\njobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['requirement1', 'requirement2']}]\njobMarketplace.remove_job(jobMarketplace.job_listings[0])\nassertEqual(jobMarketplace.job_listings, [])\n", "jobMarketplace = JobMarketplace()\njobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\nassertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n", "jobMarketplace = JobMarketplace()\njobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}]\njobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\nassertEqual(jobMarketplace.resumes, [])\n", "jobMarketplace = JobMarketplace()\njobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}]\nassertEqual(jobMarketplace.search_jobs(\"skill1\"), [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill1', 'skill2']}])\n", "jobMarketplace = JobMarketplace()\njobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}]\njobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}]\nassertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n", "jobMarketplace = JobMarketplace()\nassertEqual(jobMarketplace.matches_requirements({\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, ['skill1', 'skill2']), True)\n", "jobMarketplace = JobMarketplace()\njobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['skill1', 'skill2'])\njobMarketplace.post_job(\"Mechanical Engineer\", \"XYZ Company\", ['skill3', 'skill4'])\nassertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill1', 'skill2']}, {'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['skill3', 'skill4']}])\njobMarketplace.remove_job(jobMarketplace.job_listings[1])\nassertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill1', 'skill2']}])\njobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\nassertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\njobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\nassertEqual(jobMarketplace.resumes, [])\nassertEqual(jobMarketplace.search_jobs(\"skill1\"), [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill1', 'skill2']}])\njobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}]\nassertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\nassertEqual(jobMarketplace.matches_requirements({\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, ['skill1', 'skill2']), True)\n"], "outputs": [], "test": "import unittest\nclass JobMarketplaceTestPostJob(unittest.TestCase):\n def test_post_job(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}])\n\n def test_post_job_2(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.post_job(\"Mechanical Engineer\", \"XYZ Company\", ['requirement3', 'requirement4'])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}])\n\n def test_post_job_3(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n jobMarketplace.post_job(\"Mechanical Engineer\", \"XYZ Company\", ['requirement3', 'requirement4'])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}, {'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}])\n\n def test_post_job_4(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n jobMarketplace.post_job(\"Mechanical Engineer\", \"XYZ Company\", ['requirement3', 'requirement4'])\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}, {'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}, {'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}])\n\n def test_post_job_5(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n jobMarketplace.post_job(\"Mechanical Engineer\", \"XYZ Company\", ['requirement3', 'requirement4'])\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['requirement1', 'requirement2'])\n jobMarketplace.post_job(\"Mechanical Engineer\", \"XYZ Company\", ['requirement3', 'requirement4'])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}, {'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}, {'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}, {'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}])\n\nclass JobMarketplaceTestRemoveJob(unittest.TestCase):\n def test_remove_job(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['requirement1', 'requirement2']}]\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n self.assertEqual(jobMarketplace.job_listings, [])\n\n def test_remove_job_2(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['requirement1', 'requirement2']}, {\"job_title\": \"Mechanical Engineer\", \"company\": \"XYZ Company\", \"requirements\": ['requirement3', 'requirement4']}]\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}])\n\n def test_remove_job_3(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['requirement1', 'requirement2']}, {\"job_title\": \"Mechanical Engineer\", \"company\": \"XYZ Company\", \"requirements\": ['requirement3', 'requirement4']}]\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n self.assertEqual(jobMarketplace.job_listings, [])\n\n def test_remove_job_4(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['requirement1', 'requirement2']}, {\"job_title\": \"Mechanical Engineer\", \"company\": \"XYZ Company\", \"requirements\": ['requirement3', 'requirement4']}, {\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['requirement1', 'requirement2']}]\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}])\n\n def test_remove_job_5(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\",\n \"requirements\": ['requirement1', 'requirement2']},\n {\"job_title\": \"Mechanical Engineer\", \"company\": \"XYZ Company\",\n \"requirements\": ['requirement3', 'requirement4']},\n {\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\",\n \"requirements\": ['requirement1', 'requirement2']}]\n jobMarketplace.remove_job(jobMarketplace.job_listings[0])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['requirement3', 'requirement4']}, {'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['requirement1', 'requirement2']}])\n\nclass JobMarketplaceTestSubmitResume(unittest.TestCase):\n def test_submit_resume(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n self.assertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n\n def test_submit_resume_2(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n jobMarketplace.submit_resume(\"John\", ['skill3', 'skill4'], \"experience\")\n self.assertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}, {'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}])\n\n def test_submit_resume_3(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n jobMarketplace.submit_resume(\"John\", ['skill3', 'skill4'], \"experience\")\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n self.assertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}, {'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}, {'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n\n def test_submit_resume_4(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n jobMarketplace.submit_resume(\"John\", ['skill3', 'skill4'], \"experience\")\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n jobMarketplace.submit_resume(\"John\", ['skill3', 'skill4'], \"experience\")\n self.assertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}, {'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}, {'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}, {'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}])\n\n def test_submit_resume_5(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n jobMarketplace.submit_resume(\"John\", ['skill3', 'skill4'], \"experience\")\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n jobMarketplace.submit_resume(\"John\", ['skill3', 'skill4'], \"experience\")\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n self.assertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}, {'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}, {'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}, {'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}, {'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n\n\nclass JobMarketplaceTestWithdrawResume(unittest.TestCase):\n def test_withdraw_resume(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}]\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n self.assertEqual(jobMarketplace.resumes, [])\n\n def test_withdraw_resume_2(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n self.assertEqual(jobMarketplace.resumes, [{'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}])\n\n def test_withdraw_resume_3(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n self.assertEqual(jobMarketplace.resumes, [])\n \n def test_withdraw_resume_4(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Amy\", \"skills\": ['skill3', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n self.assertEqual(jobMarketplace.resumes, [])\n\n def test_withdraw_resume_5(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Amy\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n self.assertEqual(jobMarketplace.resumes, [{'experience': 'experience', 'name': 'John', 'skills': ['skill3', 'skill4']}])\n\nclass JobMarketplaceTestSearchJobs(unittest.TestCase):\n def test_search_jobs(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}]\n self.assertEqual(jobMarketplace.search_jobs(\"skill1\"), [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill1', 'skill2']}])\n\n def test_search_jobs_2(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}, {\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill3', 'skill4']}]\n self.assertEqual(jobMarketplace.search_jobs(\"skill1\"), [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill1', 'skill2']}])\n\n def test_search_jobs_3(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}, {\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill3', 'skill4']}]\n self.assertEqual(jobMarketplace.search_jobs(\"skill3\"), [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill3', 'skill4']}])\n\n def test_search_jobs_4(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}, {\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill3', 'skill4']}]\n self.assertEqual(jobMarketplace.search_jobs(\"skill5\"), [])\n\n def test_search_jobs_5(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}, {\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill3', 'skill4']}]\n self.assertEqual(jobMarketplace.search_jobs(\"skill6\"), [])\n\nclass JobMarketplaceTestGetJobApplicants(unittest.TestCase):\n def test_get_job_applicants(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}]\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}]\n self.assertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n\n def test_get_job_applicants_2(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill1', 'skill2']}]\n self.assertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n\n def test_get_job_applicants_3(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill3', 'skill4']}]\n self.assertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [{'name': 'John', 'skills': ['skill3', 'skill4'], 'experience': 'experience'}])\n\n def test_get_job_applicants_4(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill5', 'skill6']}]\n self.assertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [])\n\n def test_get_job_applicants_5(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, {\"name\": \"John\", \"skills\": ['skill3', 'skill4'], \"experience\": \"experience\"}]\n jobMarketplace.job_listings = [{\"job_title\": \"Software Engineer\", \"company\": \"ABC Company\", \"requirements\": ['skill6', 'skill7']}]\n self.assertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [])\n\nclass JobMarketplaceTestMatchesRequirements(unittest.TestCase):\n def test_matches_requirements(self):\n jobMarketplace = JobMarketplace()\n self.assertEqual(jobMarketplace.matches_requirements({\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, ['skill1', 'skill2']), True)\n\n def test_matches_requirements_2(self):\n jobMarketplace = JobMarketplace()\n self.assertEqual(jobMarketplace.matches_requirements({\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, ['skill3', 'skill4']), False)\n\n def test_matches_requirements_3(self):\n jobMarketplace = JobMarketplace()\n self.assertEqual(jobMarketplace.matches_requirements({\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, ['skill5', 'skill6']), False)\n\n def test_matches_requirements_4(self):\n jobMarketplace = JobMarketplace()\n self.assertEqual(jobMarketplace.matches_requirements({\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, ['skill1', 'skill3']), False)\n\n def test_matches_requirements_5(self):\n jobMarketplace = JobMarketplace()\n self.assertEqual(jobMarketplace.matches_requirements({\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, ['skill1']), False)\n\nclass JobMarketplaceTestMain(unittest.TestCase):\n def test_main(self):\n jobMarketplace = JobMarketplace()\n jobMarketplace.post_job(\"Software Engineer\", \"ABC Company\", ['skill1', 'skill2'])\n jobMarketplace.post_job(\"Mechanical Engineer\", \"XYZ Company\", ['skill3', 'skill4'])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill1', 'skill2']}, {'job_title': 'Mechanical Engineer', 'company': 'XYZ Company', 'requirements': ['skill3', 'skill4']}])\n jobMarketplace.remove_job(jobMarketplace.job_listings[1])\n self.assertEqual(jobMarketplace.job_listings, [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill1', 'skill2']}])\n jobMarketplace.submit_resume(\"Tom\", ['skill1', 'skill2'], \"experience\")\n self.assertEqual(jobMarketplace.resumes, [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n jobMarketplace.withdraw_resume(jobMarketplace.resumes[0])\n self.assertEqual(jobMarketplace.resumes, [])\n self.assertEqual(jobMarketplace.search_jobs(\"skill1\"), [{'job_title': 'Software Engineer', 'company': 'ABC Company', 'requirements': ['skill1', 'skill2']}])\n jobMarketplace.resumes = [{\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}]\n self.assertEqual(jobMarketplace.get_job_applicants(jobMarketplace.job_listings[0]), [{'name': 'Tom', 'skills': ['skill1', 'skill2'], 'experience': 'experience'}])\n self.assertEqual(jobMarketplace.matches_requirements({\"name\": \"Tom\", \"skills\": ['skill1', 'skill2'], \"experience\": \"experience\"}, ['skill1', 'skill2']), True)"} {"task_id": "DREval/122", "entry_point": "KappaCalculator", "code": "import numpy as np\n\n\nclass KappaCalculator:\n\n @staticmethod\n def kappa(testData, k):\n dataMat = np.mat(testData)\n P0 = 0.0\n for i in range(k):\n P0 += dataMat[i, i] * 1.0\n xsum = np.sum(dataMat, axis=1)\n ysum = np.sum(dataMat, axis=0)\n sum = np.sum(dataMat)\n Pe = float(ysum * xsum) / sum / sum\n P0 = float(P0 / sum * 1.0)\n cohens_coefficient = float((P0 - Pe) / (1 - Pe))\n return cohens_coefficient\n\n @staticmethod\n def fleiss_kappa(testData, N, k, n):\n dataMat = np.mat(testData, float)\n oneMat = np.ones((k, 1))\n sum = 0.0\n P0 = 0.0\n for i in range(N):\n temp = 0.0\n for j in range(k):\n sum += dataMat[i, j]\n temp += 1.0 * dataMat[i, j] ** 2\n temp -= n\n temp /= (n - 1) * n\n P0 += temp\n P0 = 1.0 * P0 / N\n ysum = np.sum(dataMat, axis=0)\n for i in range(k):\n ysum[0, i] = (ysum[0, i] / sum) ** 2\n Pe = ysum * oneMat * 1.0\n ans = (P0 - Pe) / (1 - Pe)\n return ans[0, 0]", "inputs": ["assertAlmostEqual(KappaCalculator.kappa([[2, 1, 1], [1, 2, 1], [1, 1, 2]], 3), 0.25)\n", "assertAlmostEqual(KappaCalculator.fleiss_kappa([[0, 0, 0, 0, 14],\n[0, 2, 6, 4, 2],\n[0, 0, 3, 5, 6],\n[0, 3, 9, 2, 0],\n[2, 2, 8, 1, 1],\n[7, 7, 0, 0, 0],\n[3, 2, 6, 3, 0],\n[2, 5, 3, 2, 2],\n[6, 5, 2, 1, 0],\n[0, 2, 2, 3, 7]], 10, 5, 14), 0.20993070442195522)\n", "assertAlmostEqual(KappaCalculator.kappa([[2, 1, 1], [1, 2, 1], [1, 1, 2]], 3), 0.25)\nassertAlmostEqual(KappaCalculator.fleiss_kappa([[0, 0, 0, 0, 14],\n[0, 2, 6, 4, 2],\n[0, 0, 3, 5, 6],\n[0, 3, 9, 2, 0],\n[2, 2, 8, 1, 1],\n[7, 7, 0, 0, 0],\n[3, 2, 6, 3, 0],\n[2, 5, 3, 2, 2],\n[6, 5, 2, 1, 0],\n[0, 2, 2, 3, 7]], 10, 5, 14), 0.20993070442195522)\n"], "outputs": [], "test": "import unittest\n\n\nclass KappaCalculatorTestKappa(unittest.TestCase):\n def test_kappa_1(self):\n self.assertAlmostEqual(KappaCalculator.kappa([[2, 1, 1], [1, 2, 1], [1, 1, 2]], 3), 0.25)\n\n def test_kappa_2(self):\n self.assertAlmostEqual(KappaCalculator.kappa([[2, 2, 1], [1, 2, 1], [1, 1, 2]], 3), 0.19469026548672572)\n\n def test_kappa_3(self):\n self.assertAlmostEqual(KappaCalculator.kappa([[2, 1, 2], [1, 2, 1], [1, 1, 2]], 3), 0.19469026548672572)\n\n def test_kappa_4(self):\n self.assertAlmostEqual(KappaCalculator.kappa([[2, 1, 1], [2, 2, 1], [1, 1, 2]], 3), 0.19469026548672572)\n\n def test_kappa_5(self):\n self.assertAlmostEqual(KappaCalculator.kappa([[2, 1, 1], [1, 2, 2], [1, 1, 2]], 3), 0.19469026548672572)\n\n\nclass KappaCalculatorTestFleissKappa(unittest.TestCase):\n def test_fleiss_kappa_1(self):\n self.assertAlmostEqual(KappaCalculator.fleiss_kappa([[0, 0, 0, 0, 14],\n [0, 2, 6, 4, 2],\n [0, 0, 3, 5, 6],\n [0, 3, 9, 2, 0],\n [2, 2, 8, 1, 1],\n [7, 7, 0, 0, 0],\n [3, 2, 6, 3, 0],\n [2, 5, 3, 2, 2],\n [6, 5, 2, 1, 0],\n [0, 2, 2, 3, 7]], 10, 5, 14), 0.20993070442195522)\n\n def test_fleiss_kappa_2(self):\n self.assertAlmostEqual(KappaCalculator.fleiss_kappa([[1, 0, 0, 0, 14],\n [0, 2, 6, 4, 2],\n [0, 0, 3, 5, 6],\n [0, 3, 9, 2, 0],\n [2, 2, 8, 1, 1],\n [7, 7, 0, 0, 0],\n [3, 2, 6, 3, 0],\n [2, 5, 3, 2, 2],\n [6, 5, 2, 1, 0],\n [0, 2, 2, 3, 7]], 10, 5, 14), 0.2115748928799344)\n\n def test_fleiss_kappa_3(self):\n self.assertAlmostEqual(KappaCalculator.fleiss_kappa([[0, 1, 0, 0, 14],\n [0, 2, 6, 4, 2],\n [0, 0, 3, 5, 6],\n [0, 3, 9, 2, 0],\n [2, 2, 8, 1, 1],\n [7, 7, 0, 0, 0],\n [3, 2, 6, 3, 0],\n [2, 5, 3, 2, 2],\n [6, 5, 2, 1, 0],\n [0, 2, 2, 3, 7]], 10, 5, 14), 0.21076904123090398)\n\n def test_fleiss_kappa_4(self):\n self.assertAlmostEqual(KappaCalculator.fleiss_kappa([[0, 0, 1, 0, 14],\n [0, 2, 6, 4, 2],\n [0, 0, 3, 5, 6],\n [0, 3, 9, 2, 0],\n [2, 2, 8, 1, 1],\n [7, 7, 0, 0, 0],\n [3, 2, 6, 3, 0],\n [2, 5, 3, 2, 2],\n [6, 5, 2, 1, 0],\n [0, 2, 2, 3, 7]], 10, 5, 14), 0.2096583016522883)\n\n def test_fleiss_kappa_5(self):\n self.assertAlmostEqual(KappaCalculator.fleiss_kappa([[0, 0, 0, 1, 14],\n [0, 2, 6, 4, 2],\n [0, 0, 3, 5, 6],\n [0, 3, 9, 2, 0],\n [2, 2, 8, 1, 1],\n [7, 7, 0, 0, 0],\n [3, 2, 6, 3, 0],\n [2, 5, 3, 2, 2],\n [6, 5, 2, 1, 0],\n [0, 2, 2, 3, 7]], 10, 5, 14), 0.21147425143148907)\n\n\nclass KappaCalculatorTest(unittest.TestCase):\n def test_kappacalculator(self):\n self.assertAlmostEqual(KappaCalculator.kappa([[2, 1, 1], [1, 2, 1], [1, 1, 2]], 3), 0.25)\n self.assertAlmostEqual(KappaCalculator.fleiss_kappa([[0, 0, 0, 0, 14],\n [0, 2, 6, 4, 2],\n [0, 0, 3, 5, 6],\n [0, 3, 9, 2, 0],\n [2, 2, 8, 1, 1],\n [7, 7, 0, 0, 0],\n [3, 2, 6, 3, 0],\n [2, 5, 3, 2, 2],\n [6, 5, 2, 1, 0],\n [0, 2, 2, 3, 7]], 10, 5, 14), 0.20993070442195522)"} {"task_id": "DREval/123", "entry_point": "LongestWord", "code": "import re\nimport string\n\n\nclass LongestWord:\n\n def __init__(self):\n self.word_list = []\n\n def add_word(self, word):\n self.word_list.append(word)\n\n def find_longest_word(self, sentence):\n longest_word = \"\"\n sentence = sentence.lower()\n sentence = re.sub('[%s]' % re.escape(string.punctuation), '', sentence)\n sentence = re.split(' ', sentence)\n for word in sentence:\n if word in self.word_list and len(word) > len(longest_word):\n longest_word = word\n return longest_word", "inputs": ["longestWord = LongestWord()\nlongestWord.add_word(\"hello\")\nassertEqual(['hello'], longestWord.word_list)\n", "longestWord = LongestWord()\nlongestWord.add_word(\"a\")\nsentence = 'I am a student.'\nassertEqual('a', longestWord.find_longest_word(sentence))\n"], "outputs": [], "test": "import unittest\n\nclass LongestWordTestAddWord(unittest.TestCase):\n def test_add_word_1(self):\n longestWord = LongestWord()\n longestWord.add_word(\"hello\")\n self.assertEqual(['hello'], longestWord.word_list)\n\n def test_add_word_2(self):\n longestWord = LongestWord()\n longestWord.add_word(\"hello\")\n longestWord.add_word(\"world\")\n self.assertEqual(['hello', 'world'], longestWord.word_list)\n\n def test_add_word_3(self):\n longestWord = LongestWord()\n longestWord.add_word(\"hello\")\n longestWord.add_word(\"world\")\n longestWord.add_word(\"!\")\n self.assertEqual(['hello', 'world', '!'], longestWord.word_list)\n\n def test_add_word_4(self):\n longestWord = LongestWord()\n longestWord.add_word(\"hello\")\n longestWord.add_word(\"world\")\n longestWord.add_word(\"!\")\n longestWord.add_word(\"!\")\n self.assertEqual(['hello', 'world', '!', '!'], longestWord.word_list)\n\n def test_add_word_5(self):\n longestWord = LongestWord()\n longestWord.add_word(\"hello\")\n longestWord.add_word(\"world\")\n longestWord.add_word(\"!\")\n longestWord.add_word(\"!\")\n longestWord.add_word(\"!\")\n self.assertEqual(['hello', 'world', '!', '!', '!'], longestWord.word_list)\n\n\nclass LongestWordTestFindLongestWord(unittest.TestCase):\n def test_find_longest_word_1(self):\n longestWord = LongestWord()\n longestWord.add_word(\"a\")\n sentence = 'I am a student.'\n self.assertEqual('a', longestWord.find_longest_word(sentence))\n\n def test_find_longest_word_2(self):\n longestWord = LongestWord()\n sentence = 'I am a student.'\n self.assertEqual('', longestWord.find_longest_word(sentence))\n\n def test_find_longest_word_3(self):\n longestWord = LongestWord()\n longestWord.add_word(\"student\")\n sentence = 'I am a student.'\n self.assertEqual('student', longestWord.find_longest_word(sentence))\n\n def test_find_longest_word_4(self):\n longestWord = LongestWord()\n longestWord.add_word(\"apple\")\n sentence = 'Apple is red.'\n self.assertEqual('apple', longestWord.find_longest_word(sentence))\n\n def test_find_longest_word_5(self):\n longestWord = LongestWord()\n longestWord.add_word(\"apple\")\n longestWord.add_word(\"red\")\n sentence = 'Apple is red.'\n self.assertEqual('apple', longestWord.find_longest_word(sentence))"} {"task_id": "DREval/124", "entry_point": "Manacher", "code": "class Manacher:\n def __init__(self, input_string) -> None:\n self.input_string = input_string\n\n def palindromic_length(self, center, diff, string):\n if (center - diff == -1 or center + diff == len(string)\n or string[center - diff] != string[center + diff]):\n return 0\n return 1 + self.palindromic_length(center, diff + 1, string)\n\n\n def palindromic_string(self):\n max_length = 0\n\n new_input_string = \"\"\n output_string = \"\"\n\n for i in self.input_string[:len(self.input_string) - 1]:\n new_input_string += i + \"|\"\n new_input_string += self.input_string[-1]\n\n for i in range(len(new_input_string)):\n\n length =self.palindromic_length(i, 1, new_input_string)\n\n if max_length < length:\n max_length = length\n start = i\n\n for i in new_input_string[start - max_length:start + max_length + 1]:\n if i != \"|\":\n output_string += i\n\n return output_string", "inputs": ["manacher = Manacher('ababa')\nassertEqual(manacher.palindromic_length(2, 1, 'a|b|a|b|a'), 2)\n", "manacher = Manacher('ababaxse')\nassertEqual(manacher.palindromic_string(), 'ababa')\n", "manacher = Manacher('ababa')\nassertEqual(manacher.palindromic_length(2, 1, 'a|b|a|b|a'), 2)\nassertEqual(manacher.palindromic_string(), 'ababa')\n"], "outputs": [], "test": "import unittest\n\nclass ManacherTestPalindromicLength(unittest.TestCase):\n def test_palindromic_length(self):\n manacher = Manacher('ababa')\n self.assertEqual(manacher.palindromic_length(2, 1, 'a|b|a|b|a'), 2)\n def test_palindromic_length_2(self):\n manacher = Manacher('ababaxse')\n self.assertEqual(manacher.palindromic_length(2, 1, 'a|b|a|b|a|x|s|e'), 2)\n\n def test_palindromic_length_3(self):\n manacher = Manacher('ababax')\n self.assertEqual(manacher.palindromic_length(2, 3, 'a|b|a|b|a|x'), 0)\n\n def test_palindromic_length_4(self):\n manacher = Manacher('ababax')\n self.assertEqual(manacher.palindromic_length(9, 2, 'a|b|a|b|a|x'), 0)\n\n def test_palindromic_length_5(self):\n manacher = Manacher('ababax')\n self.assertEqual(manacher.palindromic_length(4, 1, 'a|b|a|b|a|x'), 4)\n\n\nclass ManacherTestPalindromicString(unittest.TestCase):\n def test_palindromic_string(self):\n manacher = Manacher('ababaxse')\n self.assertEqual(manacher.palindromic_string(), 'ababa')\n\n def test_palindromic_string_2(self):\n manacher = Manacher('ababax')\n self.assertEqual(manacher.palindromic_string(), 'ababa')\n\n def test_palindromic_string_3(self):\n manacher = Manacher('ababax')\n self.assertEqual(manacher.palindromic_string(), 'ababa')\n\n def test_palindromic_string_4(self):\n manacher = Manacher('ababaxssss')\n self.assertEqual(manacher.palindromic_string(), 'ababa')\n\n def test_palindromic_string_5(self):\n manacher = Manacher('abab')\n self.assertEqual(manacher.palindromic_string(), 'aba')\n\n\nclass ManacherTestMain(unittest.TestCase):\n def test_main(self):\n manacher = Manacher('ababa')\n self.assertEqual(manacher.palindromic_length(2, 1, 'a|b|a|b|a'), 2)\n self.assertEqual(manacher.palindromic_string(), 'ababa')"} {"task_id": "DREval/125", "entry_point": "MetricsCalculator", "code": "class MetricsCalculator:\n def __init__(self):\n self.true_positives = 0\n self.false_positives = 0\n self.false_negatives = 0\n self.true_negatives = 0\n\n def update(self, predicted_labels, true_labels):\n for predicted, true in zip(predicted_labels, true_labels):\n if predicted == 1 and true == 1:\n self.true_positives += 1\n elif predicted == 1 and true == 0:\n self.false_positives += 1\n elif predicted == 0 and true == 1:\n self.false_negatives += 1\n elif predicted == 0 and true == 0:\n self.true_negatives += 1\n\n def precision(self, predicted_labels, true_labels):\n self.update(predicted_labels, true_labels)\n if self.true_positives + self.false_positives == 0:\n return 0.0\n return self.true_positives / (self.true_positives + self.false_positives)\n\n def recall(self, predicted_labels, true_labels):\n self.update(predicted_labels, true_labels)\n if self.true_positives + self.false_negatives == 0:\n return 0.0\n return self.true_positives / (self.true_positives + self.false_negatives)\n\n def f1_score(self, predicted_labels, true_labels):\n self.update(predicted_labels, true_labels)\n precision = self.precision(predicted_labels, true_labels)\n recall = self.recall(predicted_labels, true_labels)\n if precision + recall == 0.0:\n return 0.0\n return (2 * precision * recall) / (precision + recall)\n\n def accuracy(self, predicted_labels, true_labels):\n self.update(predicted_labels, true_labels)\n total = self.true_positives + self.true_negatives + self.false_positives + self.false_negatives\n if total == 0:\n return 0.0\n return (self.true_positives + self.true_negatives) / total", "inputs": ["mc = MetricsCalculator()\nassertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\nmc.update([1, 1, 0, 0], [1, 0, 0, 1])\nassertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (1, 1, 1, 1))\n", "mc = MetricsCalculator()\ntemp = mc.precision([1, 1, 0, 0], [1, 0, 0, 1])\nassertEqual(temp, 0.5)\n", "mc = MetricsCalculator()\ntemp = mc.recall([1, 1, 0, 0], [1, 0, 0, 1])\nassertEqual(temp, 0.5)\n", "mc = MetricsCalculator()\ntemp = mc.f1_score([1, 1, 0, 0], [1, 0, 0, 1])\nassertEqual(temp, 0.5)\n", "mc = MetricsCalculator()\ntemp = mc.accuracy([1, 1, 0, 0], [1, 0, 0, 1])\nassertEqual(temp, 0.5)\n", "mc = MetricsCalculator()\nassertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\nmc.update([1, 1, 0, 0], [1, 0, 0, 1])\nassertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (1, 1, 1, 1))\ntemp = mc.precision([1, 1, 0, 0], [1, 0, 0, 1])\nassertEqual(temp, 0.5)\ntemp = mc.recall([1, 1, 0, 0], [1, 0, 0, 1])\nassertEqual(temp, 0.5)\ntemp = mc.f1_score([1, 1, 0, 0], [1, 0, 0, 1])\nassertEqual(temp, 0.5)\ntemp = mc.accuracy([1, 1, 0, 0], [1, 0, 0, 1])\nassertEqual(temp, 0.5)\n"], "outputs": [], "test": "import unittest\n\n\nclass MetricsCalculatorTestUpdate(unittest.TestCase):\n def test_update_1(self):\n mc = MetricsCalculator()\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\n mc.update([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (1, 1, 1, 1))\n\n def test_update_2(self):\n mc = MetricsCalculator()\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\n mc.update([1, 1, 1, 0], [1, 0, 0, 1])\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (1, 2, 1, 0))\n\n def test_update_3(self):\n mc = MetricsCalculator()\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\n mc.update([1, 1, 0, 1], [1, 0, 0, 1])\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (2, 1, 0, 1))\n\n def test_update_4(self):\n mc = MetricsCalculator()\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\n mc.update([1, 1, 0, 0], [1, 1, 0, 1])\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (2, 0, 1, 1))\n\n def test_update_5(self):\n mc = MetricsCalculator()\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\n mc.update([1, 1, 0, 0], [1, 0, 1, 1])\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (1, 1, 2, 0))\n\n\nclass MetricsCalculatorTestPrecision(unittest.TestCase):\n def test_precision_1(self):\n mc = MetricsCalculator()\n temp = mc.precision([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n\n def test_precision_2(self):\n mc = MetricsCalculator()\n temp = mc.precision([1, 1, 1, 0], [1, 0, 0, 1])\n self.assertAlmostEqual(temp, 0.3333333333333333)\n\n def test_precision_3(self):\n mc = MetricsCalculator()\n temp = mc.precision([1, 1, 0, 1], [1, 0, 0, 1])\n self.assertAlmostEqual(temp, 0.6666666666666666)\n\n def test_precision_4(self):\n mc = MetricsCalculator()\n temp = mc.precision([1, 1, 0, 0], [1, 1, 0, 1])\n self.assertAlmostEqual(temp, 1.0)\n\n def test_precision_5(self):\n mc = MetricsCalculator()\n temp = mc.precision([1, 1, 0, 0], [1, 0, 1, 1])\n self.assertAlmostEqual(temp, 0.5)\n\n def test_precision_6(self):\n mc = MetricsCalculator()\n temp = mc.precision([0, 0, 0, 0], [1, 0, 1, 1])\n self.assertAlmostEqual(temp, 0.0)\n\n\nclass MetricsCalculatorTestRecall(unittest.TestCase):\n def test_recall_1(self):\n mc = MetricsCalculator()\n temp = mc.recall([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n\n def test_recall_2(self):\n mc = MetricsCalculator()\n temp = mc.recall([1, 1, 1, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n\n def test_recall_3(self):\n mc = MetricsCalculator()\n temp = mc.recall([1, 1, 0, 1], [1, 0, 0, 1])\n self.assertEqual(temp, 1.0)\n\n def test_recall_4(self):\n mc = MetricsCalculator()\n temp = mc.recall([1, 1, 0, 0], [1, 1, 0, 1])\n self.assertAlmostEqual(temp, 0.6666666666666666)\n\n def test_recall_5(self):\n mc = MetricsCalculator()\n temp = mc.recall([1, 1, 0, 0], [1, 0, 1, 1])\n self.assertAlmostEqual(temp, 0.3333333333333333)\n\n def test_recall_6(self):\n mc = MetricsCalculator()\n temp = mc.recall([1, 1, 0, 0], [0, 0, 0, 0])\n self.assertEqual(temp, 0.0)\n\n\nclass MetricsCalculatorTestF1Score(unittest.TestCase):\n def test_f1_score_1(self):\n mc = MetricsCalculator()\n temp = mc.f1_score([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n\n def test_f1_score_2(self):\n mc = MetricsCalculator()\n temp = mc.f1_score([1, 1, 1, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.4)\n\n def test_f1_score_3(self):\n mc = MetricsCalculator()\n temp = mc.f1_score([1, 1, 0, 1], [1, 0, 0, 1])\n self.assertEqual(temp, 0.8)\n\n def test_f1_score_4(self):\n mc = MetricsCalculator()\n temp = mc.f1_score([1, 1, 0, 0], [1, 1, 0, 1])\n self.assertEqual(temp, 0.8)\n\n def test_f1_score_5(self):\n mc = MetricsCalculator()\n temp = mc.f1_score([1, 1, 0, 0], [1, 0, 1, 1])\n self.assertEqual(temp, 0.4)\n\n def test_f1_score_6(self):\n mc = MetricsCalculator()\n temp = mc.f1_score([0, 0, 0, 0], [0, 0, 0, 0])\n self.assertEqual(temp, 0.0)\n\n\nclass MetricsCalculatorTestAccuracy(unittest.TestCase):\n def test_accuracy_1(self):\n mc = MetricsCalculator()\n temp = mc.accuracy([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n\n def test_accuracy_2(self):\n mc = MetricsCalculator()\n temp = mc.accuracy([1, 1, 2, 0], [1, 0, 0, 1])\n self.assertAlmostEqual(temp, 0.3333333333333333)\n\n def test_accuracy_3(self):\n mc = MetricsCalculator()\n temp = mc.accuracy([1, 1, 0, 1], [1, 0, 0, 1])\n self.assertEqual(temp, 0.75)\n\n def test_accuracy_4(self):\n mc = MetricsCalculator()\n temp = mc.accuracy([1, 1, 0, 0], [1, 1, 0, 1])\n self.assertEqual(temp, 0.75)\n\n def test_accuracy_5(self):\n mc = MetricsCalculator()\n temp = mc.accuracy([1, 1, 0, 0], [1, 0, 1, 1])\n self.assertEqual(temp, 0.25)\n\n def test_accuracy_6(self):\n mc = MetricsCalculator()\n temp = mc.accuracy([], [])\n self.assertEqual(temp, 0.0)\n\n\nclass MetricsCalculatorTest(unittest.TestCase):\n def test_metricscalculator(self):\n mc = MetricsCalculator()\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (0, 0, 0, 0))\n mc.update([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual((mc.true_positives, mc.false_positives, mc.false_negatives, mc.true_negatives), (1, 1, 1, 1))\n temp = mc.precision([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n temp = mc.recall([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n temp = mc.f1_score([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)\n temp = mc.accuracy([1, 1, 0, 0], [1, 0, 0, 1])\n self.assertEqual(temp, 0.5)"} {"task_id": "DREval/126", "entry_point": "MetricsCalculator2", "code": "import numpy as np\n\n\nclass MetricsCalculator2:\n def __init__(self):\n pass\n\n @staticmethod\n def mrr(data):\n if type(data) != list and type(data) != tuple:\n raise Exception(\"the input must be a tuple([0,...,1,...],int) or a iteration of list of tuple\")\n\n if len(data) == 0:\n return 0.0, [0.0]\n if type(data) == tuple:\n (sub_list, total_num) = data\n sub_list = np.array(sub_list)\n if total_num == 0:\n return 0.0, [0.0]\n else:\n ranking_array = 1.0 / (np.array(list(range(len(sub_list)))) + 1)\n mr_np = sub_list * ranking_array\n\n mr = 0.0\n for team in mr_np:\n if team > 0:\n mr = team\n break\n return mr, [mr]\n\n if type(data) == list:\n separate_result = []\n for (sub_list, total_num) in data:\n sub_list = np.array(sub_list)\n\n if total_num == 0:\n mr = 0.0\n else:\n ranking_array = 1.0 / (np.array(list(range(len(sub_list)))) + 1)\n mr_np = sub_list * ranking_array\n\n mr = 0.0\n for team in mr_np:\n if team > 0:\n mr = team\n break\n\n separate_result.append(mr)\n return np.mean(separate_result), separate_result\n\n @staticmethod\n def map(data):\n if type(data) != list and type(data) != tuple:\n raise Exception(\"the input must be a tuple([0,...,1,...],int) or a iteration of list of tuple\")\n\n if len(data) == 0:\n return 0.0, [0.0]\n if type(data) == tuple:\n (sub_list, total_num) = data\n sub_list = np.array(sub_list)\n if total_num == 0:\n return 0.0, [0.0]\n else:\n ranking_array = 1.0 / (np.array(list(range(len(sub_list)))) + 1)\n\n right_ranking_list = []\n count = 1\n for t in sub_list:\n if t == 0:\n right_ranking_list.append(0)\n else:\n right_ranking_list.append(count)\n count += 1\n\n ap = np.sum(np.array(right_ranking_list) * ranking_array) / total_num\n return ap, [ap]\n\n if type(data) == list:\n separate_result = []\n for (sub_list, total_num) in data:\n sub_list = np.array(sub_list)\n\n if total_num == 0:\n ap = 0.0\n else:\n ranking_array = 1.0 / (np.array(list(range(len(sub_list)))) + 1)\n\n right_ranking_list = []\n count = 1\n for t in sub_list:\n if t == 0:\n right_ranking_list.append(0)\n else:\n right_ranking_list.append(count)\n count += 1\n\n ap = np.sum(np.array(right_ranking_list) * ranking_array) / total_num\n\n separate_result.append(ap)\n return np.mean(separate_result), separate_result", "inputs": ["mc2 = MetricsCalculator2()\nres1, res2 = MetricsCalculator2.mrr(([1, 0, 1, 0], 4))\nassertEqual(res1, 1.0)\nassertEqual(res2, [1.0])\n", "res1, res2 = MetricsCalculator2.map(([1, 0, 1, 0], 4))\nassertEqual(res1, 0.41666666666666663)\nassertEqual(res2, [0.41666666666666663])\n", "res1, res2 = MetricsCalculator2.mrr(([1, 0, 1, 0], 4))\nassertEqual(res1, 1.0)\nassertEqual(res2, [1.0])\n"], "outputs": [], "test": "import unittest\n\n\nclass MetricsCalculator2TestMrr(unittest.TestCase):\n def test_mrr_1(self):\n mc2 = MetricsCalculator2()\n res1, res2 = MetricsCalculator2.mrr(([1, 0, 1, 0], 4))\n self.assertEqual(res1, 1.0)\n self.assertEqual(res2, [1.0])\n\n def test_mrr_2(self):\n res1, res2 = MetricsCalculator2.mrr(([0, 0, 0, 1], 4))\n self.assertEqual(res1, 0.25)\n self.assertEqual(res2, [0.25])\n\n def test_mrr_3(self):\n res1, res2 = MetricsCalculator2.mrr([([1, 0, 1, 0], 4), ([0, 1, 0, 1], 4)])\n self.assertEqual(res1, 0.75)\n self.assertEqual(res2, [1.0, 0.5])\n\n def test_mrr_4(self):\n res1, res2 = MetricsCalculator2.mrr([([1, 1, 1, 0], 4), ([0, 0, 0, 1], 4)])\n self.assertEqual(res1, 0.625)\n self.assertEqual(res2, [1.0, 0.25])\n\n def test_mrr_5(self):\n res1, res2 = MetricsCalculator2.mrr([([1, 0, 1, 1], 4), ([0, 1, 0, 0], 4)])\n self.assertEqual(res1, 0.75)\n self.assertEqual(res2, [1.0, 0.5])\n\n def test_mrr_6(self):\n try:\n MetricsCalculator2.mrr(1)\n except:\n pass\n\n def test_mrr_7(self):\n res1, res2 = MetricsCalculator2.mrr([])\n self.assertEqual(res1, 0.0)\n self.assertEqual(res2, [0.0])\n\n def test_mrr_8(self):\n res1, res2 = MetricsCalculator2.mrr([([1, 0, 1, 1], 0), ([0, 1, 0, 0], 0)])\n self.assertEqual(res1, 0.0)\n self.assertEqual(res2, [0.0, 0.0])\n\n\nclass MetricsCalculator2TestMap(unittest.TestCase):\n def test_map_1(self):\n res1, res2 = MetricsCalculator2.map(([1, 0, 1, 0], 4))\n self.assertEqual(res1, 0.41666666666666663)\n self.assertEqual(res2, [0.41666666666666663])\n\n def test_map_2(self):\n res1, res2 = MetricsCalculator2.map(([0, 0, 0, 1], 4))\n self.assertEqual(res1, 0.0625)\n self.assertEqual(res2, [0.0625])\n\n def test_map_3(self):\n res1, res2 = MetricsCalculator2.map([([1, 0, 1, 0], 4), ([0, 1, 0, 1], 4)])\n self.assertEqual(res1, 0.3333333333333333)\n self.assertEqual(res2, [0.41666666666666663, 0.25])\n\n def test_map_4(self):\n res1, res2 = MetricsCalculator2.map([([1, 1, 1, 0], 4), ([0, 0, 0, 1], 4)])\n self.assertEqual(res1, 0.40625)\n self.assertEqual(res2, [0.75, 0.0625])\n\n def test_map_5(self):\n res1, res2 = MetricsCalculator2.map([([1, 0, 1, 1], 4), ([0, 1, 0, 0], 4)])\n self.assertEqual(res1, 0.3645833333333333)\n self.assertEqual(res2, [0.6041666666666666, 0.125])\n\n def test_map_6(self):\n try:\n MetricsCalculator2.map(1)\n except:\n pass\n\n def test_map_7(self):\n res1, res2 = MetricsCalculator2.map([])\n self.assertEqual(res1, 0.0)\n self.assertEqual(res2, [0.0])\n\n def test_map_8(self):\n res1, res2 = MetricsCalculator2.map([([1, 0, 1, 1], 0), ([0, 1, 0, 0], 0)])\n self.assertEqual(res1, 0.0)\n self.assertEqual(res2, [0.0, 0.0])\n\n\nclass MetricsCalculator2Test(unittest.TestCase):\n def test_metricscalculator2_1(self):\n res1, res2 = MetricsCalculator2.mrr(([1, 0, 1, 0], 4))\n self.assertEqual(res1, 1.0)\n self.assertEqual(res2, [1.0])\n\n def test_metricscalculator2_2(self):\n res1, res2 = MetricsCalculator2.mrr([([1, 0, 1, 0], 4), ([0, 1, 0, 1], 4)])\n self.assertEqual(res1, 0.75)\n self.assertEqual(res2, [1.0, 0.5])\n\n def test_metricscalculator2_3(self):\n res1, res2 = MetricsCalculator2.map(([1, 0, 1, 0], 4))\n self.assertEqual(res1, 0.41666666666666663)\n self.assertEqual(res2, [0.41666666666666663])\n\n def test_metricscalculator2_4(self):\n res1, res2 = MetricsCalculator2.map([([1, 0, 1, 0], 4), ([0, 1, 0, 1], 4)])\n self.assertEqual(res1, 0.3333333333333333)\n self.assertEqual(res2, [0.41666666666666663, 0.25])"} {"task_id": "DREval/127", "entry_point": "MovieBookingSystem", "code": "from datetime import datetime\nimport numpy as np\n\nclass MovieBookingSystem:\n def __init__(self):\n self.movies = []\n\n def add_movie(self, name, price, start_time, end_time, n):\n movie = {\n 'name': name,\n 'price': price,\n 'start_time': datetime.strptime(start_time, '%H:%M'),\n 'end_time': datetime.strptime(end_time, '%H:%M'),\n 'seats': np.zeros((n, n))\n }\n self.movies.append(movie)\n\n def book_ticket(self, name, seats_to_book):\n for movie in self.movies:\n if movie['name'] == name:\n for seat in seats_to_book:\n if movie['seats'][seat[0]][seat[1]] == 0:\n movie['seats'][seat[0]][seat[1]] = 1\n else:\n return \"Booking failed.\"\n return \"Booking success.\"\n return \"Movie not found.\"\n\n\n def available_movies(self, start_time, end_time):\n start_time = datetime.strptime(start_time, '%H:%M')\n end_time = datetime.strptime(end_time, '%H:%M')\n\n available_movies = []\n for movie in self.movies:\n if start_time <= movie['start_time'] and movie['end_time'] <= end_time:\n available_movies.append(movie['name'])\n\n return available_movies", "inputs": ["self.system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\nassertEqual(len(self.system.movies), 1)\nassertEqual(self.system.movies[0]['name'], 'Batman')\nassertEqual(self.system.movies[0]['price'], 49.9)\nassertEqual(self.system.movies[0]['start_time'], datetime.strptime('17:05', '%H:%M'))\nassertEqual(self.system.movies[0]['end_time'], datetime.strptime('19:25', '%H:%M'))\nassertEqual(self.system.movies[0]['seats'].shape, (3, 3))\n", "result = self.system.book_ticket('Batman', [(0, 0), (1, 1), (2, 2)])\nassertEqual(result, 'Booking success.')\nassertEqual(self.system.movies[0]['seats'][0][0], 1)\nassertEqual(self.system.movies[0]['seats'][1][1], 1)\nassertEqual(self.system.movies[0]['seats'][2][2], 1)\n", "result = self.system.available_movies('16:00', '23:00')\nassertEqual(result, ['Batman', 'Spiderman'])\n", "system = MovieBookingSystem()\nsystem.add_movie('Batman', 49.9, '17:05', '19:25', 3)\nassertEqual(len(system.movies), 1)\nassertEqual(system.movies[0]['name'], 'Batman')\nassertEqual(system.movies[0]['price'], 49.9)\nassertEqual(system.movies[0]['start_time'], datetime.strptime('17:05', '%H:%M'))\nassertEqual(system.movies[0]['end_time'], datetime.strptime('19:25', '%H:%M'))\nassertEqual(system.movies[0]['seats'].shape, (3, 3))\nresult = system.book_ticket('Batman', [(0, 0), (1, 1), (2, 2)])\nassertEqual(result, 'Booking success.')\nassertEqual(system.movies[0]['seats'][0][0], 1)\nassertEqual(system.movies[0]['seats'][1][1], 1)\nassertEqual(system.movies[0]['seats'][2][2], 1)\nresult = system.available_movies('16:00', '23:00')\nassertEqual(result, ['Batman'])\n"], "outputs": [], "test": "import unittest\n\n\nclass MovieBookingSystemTestAddMovie(unittest.TestCase):\n def setUp(self):\n self.system = MovieBookingSystem()\n\n def tearDown(self):\n self.system = None\n\n def test_add_movie_1(self):\n self.system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\n self.assertEqual(len(self.system.movies), 1)\n self.assertEqual(self.system.movies[0]['name'], 'Batman')\n self.assertEqual(self.system.movies[0]['price'], 49.9)\n self.assertEqual(self.system.movies[0]['start_time'], datetime.strptime('17:05', '%H:%M'))\n self.assertEqual(self.system.movies[0]['end_time'], datetime.strptime('19:25', '%H:%M'))\n self.assertEqual(self.system.movies[0]['seats'].shape, (3, 3))\n\n def test_add_movie_2(self):\n self.system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\n self.system.add_movie('Superman', 49.9, '17:05', '19:25', 3)\n self.assertEqual(len(self.system.movies), 2)\n self.assertEqual(self.system.movies[0]['name'], 'Batman')\n self.assertEqual(self.system.movies[1]['name'], 'Superman')\n\n def test_add_movie_3(self):\n self.system.add_movie('Batman', 39.9, '17:05', '19:25', 3)\n self.assertEqual(len(self.system.movies), 1)\n self.assertEqual(self.system.movies[0]['name'], 'Batman')\n self.assertEqual(self.system.movies[0]['price'], 39.9)\n self.assertEqual(self.system.movies[0]['start_time'], datetime.strptime('17:05', '%H:%M'))\n self.assertEqual(self.system.movies[0]['end_time'], datetime.strptime('19:25', '%H:%M'))\n self.assertEqual(self.system.movies[0]['seats'].shape, (3, 3))\n\n def test_add_movie_4(self):\n self.system.add_movie('Batman', 29.9, '17:05', '19:25', 3)\n self.assertEqual(len(self.system.movies), 1)\n self.assertEqual(self.system.movies[0]['name'], 'Batman')\n self.assertEqual(self.system.movies[0]['price'], 29.9)\n self.assertEqual(self.system.movies[0]['start_time'], datetime.strptime('17:05', '%H:%M'))\n self.assertEqual(self.system.movies[0]['end_time'], datetime.strptime('19:25', '%H:%M'))\n self.assertEqual(self.system.movies[0]['seats'].shape, (3, 3))\n\n def test_add_movie_5(self):\n self.system.add_movie('Batman', 19.9, '17:05', '19:25', 3)\n self.assertEqual(len(self.system.movies), 1)\n self.assertEqual(self.system.movies[0]['name'], 'Batman')\n self.assertEqual(self.system.movies[0]['price'], 19.9)\n self.assertEqual(self.system.movies[0]['start_time'], datetime.strptime('17:05', '%H:%M'))\n self.assertEqual(self.system.movies[0]['end_time'], datetime.strptime('19:25', '%H:%M'))\n self.assertEqual(self.system.movies[0]['seats'].shape, (3, 3))\n\n\nclass MovieBookingSystemTestBookTicket(unittest.TestCase):\n def setUp(self):\n self.system = MovieBookingSystem()\n self.system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\n\n # book successfully\n def test_book_ticket_1(self):\n result = self.system.book_ticket('Batman', [(0, 0), (1, 1), (2, 2)])\n self.assertEqual(result, 'Booking success.')\n self.assertEqual(self.system.movies[0]['seats'][0][0], 1)\n self.assertEqual(self.system.movies[0]['seats'][1][1], 1)\n self.assertEqual(self.system.movies[0]['seats'][2][2], 1)\n\n # seat is not available\n def test_book_ticket_2(self):\n self.system.book_ticket('Batman', [(0, 0)])\n result = self.system.book_ticket('Batman', [(0, 0)])\n self.assertEqual(result, 'Booking failed.')\n self.assertEqual(self.system.movies[0]['seats'][0][0], 1)\n\n def test_book_ticket_3(self):\n result = self.system.book_ticket('batman', [(0, 0)])\n self.assertEqual(result, 'Movie not found.')\n self.assertEqual(self.system.movies[0]['seats'][0][0], 0)\n\n def test_book_ticket_4(self):\n result = self.system.book_ticket('Batman', [(0, 0), (1, 1)])\n self.assertEqual(result, 'Booking success.')\n self.assertEqual(self.system.movies[0]['seats'][0][0], 1)\n self.assertEqual(self.system.movies[0]['seats'][1][1], 1)\n\n def test_book_ticket_5(self):\n result = self.system.book_ticket('Batman', [(0, 0)])\n self.assertEqual(result, 'Booking success.')\n self.assertEqual(self.system.movies[0]['seats'][0][0], 1)\n\n\nclass MovieBookingSystemTestAvailableMovies(unittest.TestCase):\n def setUp(self):\n self.system = MovieBookingSystem()\n self.system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\n self.system.add_movie('Spiderman', 59.9, '20:00', '22:30', 4)\n\n def test_available_movies_1(self):\n result = self.system.available_movies('16:00', '23:00')\n self.assertEqual(result, ['Batman', 'Spiderman'])\n\n def test_available_movies_2(self):\n result = self.system.available_movies('23:00', '23:59')\n self.assertEqual(result, [])\n\n def test_available_movies_3(self):\n result = self.system.available_movies('17:00', '20:00')\n self.assertEqual(result, ['Batman'])\n\n def test_available_movies_4(self):\n result = self.system.available_movies('10:00', '23:00')\n self.assertEqual(result, ['Batman', 'Spiderman'])\n\n def test_available_movies_5(self):\n result = self.system.available_movies('20:00', '23:00')\n self.assertEqual(result, ['Spiderman'])\n\n\nclass MovieBookingSystemTestMain(unittest.TestCase):\n def test_main(self):\n system = MovieBookingSystem()\n system.add_movie('Batman', 49.9, '17:05', '19:25', 3)\n self.assertEqual(len(system.movies), 1)\n self.assertEqual(system.movies[0]['name'], 'Batman')\n self.assertEqual(system.movies[0]['price'], 49.9)\n self.assertEqual(system.movies[0]['start_time'], datetime.strptime('17:05', '%H:%M'))\n self.assertEqual(system.movies[0]['end_time'], datetime.strptime('19:25', '%H:%M'))\n self.assertEqual(system.movies[0]['seats'].shape, (3, 3))\n\n result = system.book_ticket('Batman', [(0, 0), (1, 1), (2, 2)])\n self.assertEqual(result, 'Booking success.')\n self.assertEqual(system.movies[0]['seats'][0][0], 1)\n self.assertEqual(system.movies[0]['seats'][1][1], 1)\n self.assertEqual(system.movies[0]['seats'][2][2], 1)\n\n result = system.available_movies('16:00', '23:00')\n self.assertEqual(result, ['Batman'])"} {"task_id": "DREval/128", "entry_point": "NLPDataProcessor", "code": "class NLPDataProcessor:\n\n def construct_stop_word_list(self):\n stop_word_list = ['a', 'an', 'the']\n return stop_word_list\n\n def remove_stop_words(self, string_list, stop_word_list):\n answer = []\n for string in string_list:\n string_split = string.split()\n for word in string_split:\n if word in stop_word_list:\n string_split.remove(word)\n answer.append(string_split)\n return answer\n\n def process(self, string_list):\n stop_word_list = self.construct_stop_word_list()\n words_list = self.remove_stop_words(string_list, stop_word_list)\n return words_list", "inputs": ["stop_word_list = self.processor.construct_stop_word_list()\nexpected_stop_words = ['a', 'an', 'the']\nassertEqual(stop_word_list, expected_stop_words)\n", "string_list = ['This is a test', 'This is an apple', 'This is the dog']\nstop_word_list = ['a', 'an', 'the']\nwords_list = self.processor.remove_stop_words(string_list, stop_word_list)\nexpected_words_list = [['This', 'is', 'test'], ['This', 'is', 'apple'], ['This', 'is', 'dog']]\nassertEqual(words_list, expected_words_list)\n", "string_list = ['This is a test.', 'This is an apple.', 'This is the dog.']\nwords_list = self.processor.process(string_list)\nexpected_words_list = [['This', 'is', 'test.'], ['This', 'is', 'apple.'], ['This', 'is', 'dog.']]\nassertEqual(words_list, expected_words_list)\n"], "outputs": [], "test": "import unittest\n\nclass NLPDataProcessorTestConstruct(unittest.TestCase):\n def setUp(self):\n self.processor = NLPDataProcessor()\n\n def test_construct_stop_word_list(self):\n stop_word_list = self.processor.construct_stop_word_list()\n expected_stop_words = ['a', 'an', 'the']\n self.assertEqual(stop_word_list, expected_stop_words)\n\nclass NLPDataProcessorTestRemove(unittest.TestCase):\n def setUp(self):\n self.processor = NLPDataProcessor()\n\n def test_remove_stop_words(self):\n string_list = ['This is a test', 'This is an apple', 'This is the dog']\n stop_word_list = ['a', 'an', 'the']\n words_list = self.processor.remove_stop_words(string_list, stop_word_list)\n expected_words_list = [['This', 'is', 'test'], ['This', 'is', 'apple'], ['This', 'is', 'dog']]\n self.assertEqual(words_list, expected_words_list)\n\n def test_remove_stop_words_2(self):\n string_list = ['a', 'an', 'the']\n stop_word_list = ['a', 'an', 'the']\n words_list = self.processor.remove_stop_words(string_list, stop_word_list)\n self.assertEqual(words_list, [[], [], []])\n\n def test_remove_stop_words_3(self):\n string_list = []\n stop_word_list = ['a', 'an', 'the']\n words_list = self.processor.remove_stop_words(string_list, stop_word_list)\n self.assertEqual(words_list, [])\n\n def test_remove_stop_words_4(self):\n string_list = ['This is a test', 'This is an apple', 'This is the dog']\n stop_word_list = []\n words_list = self.processor.remove_stop_words(string_list, stop_word_list)\n expected_words_list = [['This', 'is', 'a', 'test'], ['This', 'is', 'an', 'apple'], ['This', 'is', 'the', 'dog']]\n self.assertEqual(words_list, expected_words_list)\n\n def test_remove_stop_words_5(self):\n string_list = ['This is a test', 'This is an apple', 'This is the dog']\n stop_word_list = ['a', 'an', 'the', 'This', 'is']\n words_list = self.processor.remove_stop_words(string_list, stop_word_list)\n expected_words_list = [['is', 'test'], ['is', 'apple'], ['is', 'dog']]\n self.assertEqual(words_list, expected_words_list)\n\nclass NLPDataProcessorTestProcess(unittest.TestCase):\n def setUp(self):\n self.processor = NLPDataProcessor()\n\n def test_process(self):\n string_list = ['This is a test.', 'This is an apple.', 'This is the dog.']\n words_list = self.processor.process(string_list)\n expected_words_list = [['This', 'is', 'test.'], ['This', 'is', 'apple.'], ['This', 'is', 'dog.']]\n self.assertEqual(words_list, expected_words_list)\n\n def test_process_with_empty_string_list(self):\n string_list = []\n words_list = self.processor.process(string_list)\n self.assertEqual(words_list, [])\n\n def test_process_with_single_word_sentences(self):\n string_list = ['Hello aa', 'World']\n words_list = self.processor.process(string_list)\n expected_words_list = [['Hello', 'aa'], ['World']]\n self.assertEqual(words_list, expected_words_list)\n\n def test_process_with_stop_words_only(self):\n string_list = ['a', 'an', 'the']\n words_list = self.processor.process(string_list)\n self.assertEqual(words_list, [[], [], []])\n\n def test_process_with_stop_words_only_2(self):\n string_list = ['a', 'an', 'the','This']\n words_list = self.processor.process(string_list)\n self.assertEqual(words_list,[[], [], [], ['This']])"} {"task_id": "DREval/129", "entry_point": "NumberConverter", "code": "class NumberConverter:\n @staticmethod\n def decimal_to_binary(decimal_num):\n binary_num = bin(decimal_num)[2:]\n return binary_num\n\n @staticmethod\n def binary_to_decimal(binary_num):\n decimal_num = int(binary_num, 2)\n return decimal_num\n\n @staticmethod\n def decimal_to_octal(decimal_num):\n octal_num = oct(decimal_num)[2:]\n return octal_num\n\n @staticmethod\n def octal_to_decimal(octal_num):\n decimal_num = int(octal_num, 8)\n return decimal_num\n\n @staticmethod\n def decimal_to_hex(decimal_num):\n hex_num = hex(decimal_num)[2:]\n return hex_num\n\n @staticmethod\n def hex_to_decimal(hex_num):\n decimal_num = int(hex_num, 16)\n return decimal_num", "inputs": ["assertEqual('1010010110110111', NumberConverter.decimal_to_binary(42423))\n", "assertEqual(42423, NumberConverter.binary_to_decimal('1010010110110111'))\n"], "outputs": [], "test": "import unittest\n\n\nclass NumberConverterTestDecimalToBinary(unittest.TestCase):\n def test_decimal_to_binary(self):\n self.assertEqual('1010010110110111', NumberConverter.decimal_to_binary(42423))\n\n def test_decimal_to_binary_2(self):\n self.assertEqual('101001100010111', NumberConverter.decimal_to_binary(21271))\n\n def test_decimal_to_binary_3(self):\n self.assertEqual('1010010111010111', NumberConverter.decimal_to_binary(42455))\n\n def test_decimal_to_binary_4(self):\n self.assertEqual('10100101110101011', NumberConverter.decimal_to_binary(84907))\n\n def test_decimal_to_binary_5(self):\n self.assertEqual('101001011101010111', NumberConverter.decimal_to_binary(169815))\n\nclass NumberConverterTestBinaryToDecimal(unittest.TestCase):\n def test_binary_to_decimal(self):\n self.assertEqual(42423, NumberConverter.binary_to_decimal('1010010110110111'))\n\n def test_binary_to_decimal_2(self):\n self.assertEqual(10615, NumberConverter.binary_to_decimal('10100101110111'))\n\n def test_binary_to_decimal_3(self):\n self.assertEqual(42455, NumberConverter.binary_to_decimal('1010010111010111'))\n\n def test_binary_to_decimal_4(self):\n self.assertEqual(169819, NumberConverter.binary_to_decimal('101001011101011011'))\n\n def test_binary_to_decimal_5(self):\n self.assertEqual(339639, NumberConverter.binary_to_decimal('1010010111010110111'))\n\nclass NumberConvertTestDecimalToOctal(unittest.TestCase):\n def test_decimal_to_octal(self):\n self.assertEqual('122667', NumberConverter.decimal_to_octal(42423))\n\n def test_decimal_to_octal_2(self):\n self.assertEqual('51427', NumberConverter.decimal_to_octal(21271))\n\n def test_decimal_to_octal_3(self):\n self.assertEqual('245653', NumberConverter.decimal_to_octal(84907))\n\n def test_decimal_to_octal_4(self):\n self.assertEqual('513527', NumberConverter.decimal_to_octal(169815))\n\n def test_decimal_to_octal_5(self):\n self.assertEqual('1227256', NumberConverter.decimal_to_octal(339630))\n\nclass NumberConvertTestOctalToDecimal(unittest.TestCase):\n def test_octal_to_decimal(self):\n self.assertEqual(42423, NumberConverter.octal_to_decimal('122667'))\n\n def test_octal_to_decimal_2(self):\n self.assertEqual(21271, NumberConverter.octal_to_decimal('51427'))\n\n def test_octal_to_decimal_3(self):\n self.assertEqual(84907, NumberConverter.octal_to_decimal('245653'))\n\n def test_octal_to_decimal_4(self):\n self.assertEqual(169815, NumberConverter.octal_to_decimal('513527'))\n\n def test_octal_to_decimal_5(self):\n self.assertEqual(339630, NumberConverter.octal_to_decimal('1227256'))\n\nclass NumberConvertTestDecimalToHex(unittest.TestCase):\n def test_decimal_to_hex(self):\n self.assertEqual('a5b7', NumberConverter.decimal_to_hex(42423))\n\n def test_decimal_to_hex_2(self):\n self.assertEqual('5317', NumberConverter.decimal_to_hex(21271))\n\n def test_decimal_to_hex_3(self):\n self.assertEqual('14bab', NumberConverter.decimal_to_hex(84907))\n\n def test_decimal_to_hex_4(self):\n self.assertEqual('29757', NumberConverter.decimal_to_hex(169815))\n\n def test_decimal_to_hex_5(self):\n self.assertEqual('52eb7', NumberConverter.decimal_to_hex(339639))\n\nclass NumberConvertTestHexToDecimal(unittest.TestCase):\n def test_hex_to_decimal(self):\n self.assertEqual(42423, NumberConverter.hex_to_decimal('a5b7'))\n\n def test_hex_to_decimal_2(self):\n self.assertEqual(21207, NumberConverter.hex_to_decimal('52d7'))\n\n def test_hex_to_decimal_3(self):\n self.assertEqual(84627, NumberConverter.hex_to_decimal('14a93'))\n\n def test_hex_to_decimal_4(self):\n self.assertEqual(170615, NumberConverter.hex_to_decimal('29a77'))\n\n def test_hex_to_decimal_5(self):\n self.assertEqual(342647, NumberConverter.hex_to_decimal('53a77'))\n\nclass NumberConvertTestMain(unittest.TestCase):\n def test_main(self):\n self.assertEqual('1010010110110111', NumberConverter.decimal_to_binary(42423))\n self.assertEqual(42423, NumberConverter.binary_to_decimal('1010010110110111'))\n self.assertEqual('122667', NumberConverter.decimal_to_octal(42423))\n self.assertEqual('122667', NumberConverter.decimal_to_octal(42423))\n self.assertEqual('a5b7', NumberConverter.decimal_to_hex(42423))\n self.assertEqual(42423, NumberConverter.hex_to_decimal('a5b7'))"} {"task_id": "DREval/130", "entry_point": "NumberWordFormatter", "code": "class NumberWordFormatter:\n def __init__(self):\n self.NUMBER = [\"\", \"ONE\", \"TWO\", \"THREE\", \"FOUR\", \"FIVE\", \"SIX\", \"SEVEN\", \"EIGHT\", \"NINE\"]\n self.NUMBER_TEEN = [\"TEN\", \"ELEVEN\", \"TWELVE\", \"THIRTEEN\", \"FOURTEEN\", \"FIFTEEN\", \"SIXTEEN\", \"SEVENTEEN\",\n \"EIGHTEEN\",\n \"NINETEEN\"]\n self.NUMBER_TEN = [\"TEN\", \"TWENTY\", \"THIRTY\", \"FORTY\", \"FIFTY\", \"SIXTY\", \"SEVENTY\", \"EIGHTY\", \"NINETY\"]\n self.NUMBER_MORE = [\"\", \"THOUSAND\", \"MILLION\", \"BILLION\"]\n self.NUMBER_SUFFIX = [\"k\", \"w\", \"\", \"m\", \"\", \"\", \"b\", \"\", \"\", \"t\", \"\", \"\", \"p\", \"\", \"\", \"e\"]\n\n def format(self, x):\n if x is not None:\n return self.format_string(str(x))\n else:\n return \"\"\n\n def format_string(self, x):\n lstr, rstr = (x.split('.') + [''])[:2]\n lstrrev = lstr[::-1]\n a = [''] * 5\n\n if len(lstrrev) % 3 == 1:\n lstrrev += \"00\"\n elif len(lstrrev) % 3 == 2:\n lstrrev += \"0\"\n\n lm = \"\"\n for i in range(len(lstrrev) // 3):\n a[i] = lstrrev[3 * i:3 * i + 3][::-1]\n if a[i] != \"000\":\n lm = self.trans_three(a[i]) + \" \" + self.parse_more(i) + \" \" + lm\n else:\n lm += self.trans_three(a[i])\n\n xs = f\"AND CENTS {self.trans_two(rstr)} \" if rstr else \"\"\n if not lm.strip():\n return \"ZERO ONLY\"\n else:\n return f\"{lm.strip()} {xs}ONLY\"\n\n def trans_two(self, s):\n s = s.zfill(2)\n if s[0] == \"0\":\n return self.NUMBER[int(s[-1])]\n elif s[0] == \"1\":\n return self.NUMBER_TEEN[int(s) - 10]\n elif s[1] == \"0\":\n return self.NUMBER_TEN[int(s[0]) - 1]\n else:\n return self.NUMBER_TEN[int(s[0]) - 1] + \" \" + self.NUMBER[int(s[-1])]\n\n def trans_three(self, s):\n if s[0] == \"0\":\n return self.trans_two(s[1:])\n elif s[1:] == \"00\":\n return f\"{self.NUMBER[int(s[0])]} HUNDRED\"\n else:\n return f\"{self.NUMBER[int(s[0])]} HUNDRED AND {self.trans_two(s[1:])}\"\n\n def parse_more(self, i):\n return self.NUMBER_MORE[i]", "inputs": ["formatter = NumberWordFormatter()\nassertEqual(formatter.format(123456),\n\"ONE HUNDRED AND TWENTY THREE THOUSAND FOUR HUNDRED AND FIFTY SIX ONLY\")\n", "formatter = NumberWordFormatter()\nassertEqual(formatter.format_string('123456'),\n\"ONE HUNDRED AND TWENTY THREE THOUSAND FOUR HUNDRED AND FIFTY SIX ONLY\")\n", "formatter = NumberWordFormatter()\nassertEqual(formatter.trans_two(\"23\"), \"TWENTY THREE\")\n", "formatter = NumberWordFormatter()\nassertEqual(formatter.trans_three(\"123\"), \"ONE HUNDRED AND TWENTY THREE\")\n", "formatter = NumberWordFormatter()\nassertEqual(formatter.parse_more(0), \"\")\n", "formatter = NumberWordFormatter()\nassertEqual(formatter.format(123456),\n\"ONE HUNDRED AND TWENTY THREE THOUSAND FOUR HUNDRED AND FIFTY SIX ONLY\")\nformatter = NumberWordFormatter()\nassertEqual(formatter.format_string('123456'),\n\"ONE HUNDRED AND TWENTY THREE THOUSAND FOUR HUNDRED AND FIFTY SIX ONLY\")\nformatter = NumberWordFormatter()\nassertEqual(formatter.trans_two(\"23\"), \"TWENTY THREE\")\nformatter = NumberWordFormatter()\nassertEqual(formatter.trans_three(\"123\"), \"ONE HUNDRED AND TWENTY THREE\")\nformatter = NumberWordFormatter()\nassertEqual(formatter.parse_more(1), \"THOUSAND\")\n"], "outputs": [], "test": "import unittest\n\n\nclass NumberWordFormatterTestFormat(unittest.TestCase):\n def test_format_1(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(123456),\n \"ONE HUNDRED AND TWENTY THREE THOUSAND FOUR HUNDRED AND FIFTY SIX ONLY\")\n\n def test_format_2(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(1000), \"ONE THOUSAND ONLY\")\n\n def test_format_3(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(1000000), \"ONE MILLION ONLY\")\n\n def test_format_4(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(1.23), \"ONE AND CENTS TWENTY THREE ONLY\")\n\n def test_format_5(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(0), \"ZERO ONLY\")\n\n def test_format_6(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(None), \"\")\n\n\nclass NumberWordFormatterTestFormatString(unittest.TestCase):\n def test_format_string_1(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('123456'),\n \"ONE HUNDRED AND TWENTY THREE THOUSAND FOUR HUNDRED AND FIFTY SIX ONLY\")\n\n def test_format_string_2(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('1000'), \"ONE THOUSAND ONLY\")\n\n def test_format_string_3(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('1000000'), \"ONE MILLION ONLY\")\n\n def test_format_string_4(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('1.23'), \"ONE AND CENTS TWENTY THREE ONLY\")\n\n def test_format_string_5(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('0'), \"ZERO ONLY\")\n\n def test_format_string_6(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('10'), \"TEN ONLY\")\n\n\nclass NumberWordFormatterTestTransTwo(unittest.TestCase):\n def test_trans_two_1(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"23\"), \"TWENTY THREE\")\n\n def test_trans_two_2(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"10\"), \"TEN\")\n\n def test_trans_two_3(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"05\"), \"FIVE\")\n\n def test_trans_two_4(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"00\"), \"\")\n\n def test_trans_two_5(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"01\"), \"ONE\")\n\n def test_trans_two_6(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"80\"), \"EIGHTY\")\n\n\nclass NumberWordFormatterTestTransThree(unittest.TestCase):\n def test_trans_three_1(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_three(\"123\"), \"ONE HUNDRED AND TWENTY THREE\")\n\n def test_trans_three_2(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_three(\"900\"), \"NINE HUNDRED\")\n\n def test_trans_three_3(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_three(\"007\"), \"SEVEN\")\n\n def test_trans_three_4(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_three(\"001\"), \"ONE\")\n\n def test_trans_three_5(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_three(\"006\"), \"SIX\")\n\n\nclass NumberWordFormatterTestParseMore(unittest.TestCase):\n def test_parse_more_1(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.parse_more(0), \"\")\n\n def test_parse_more_2(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.parse_more(1), \"THOUSAND\")\n\n def test_parse_more_3(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.parse_more(2), \"MILLION\")\n\n def test_parse_more_4(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.parse_more(3), \"BILLION\")\n\n\nclass NumberWordFormatterTest(unittest.TestCase):\n def test_NumberWordFormatter(self):\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format(123456),\n \"ONE HUNDRED AND TWENTY THREE THOUSAND FOUR HUNDRED AND FIFTY SIX ONLY\")\n\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.format_string('123456'),\n \"ONE HUNDRED AND TWENTY THREE THOUSAND FOUR HUNDRED AND FIFTY SIX ONLY\")\n\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_two(\"23\"), \"TWENTY THREE\")\n\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.trans_three(\"123\"), \"ONE HUNDRED AND TWENTY THREE\")\n\n formatter = NumberWordFormatter()\n self.assertEqual(formatter.parse_more(1), \"THOUSAND\")"} {"task_id": "DREval/131", "entry_point": "NumericEntityUnescaper", "code": "class NumericEntityUnescaper:\n def __init__(self):\n pass\n\n def replace(self, string):\n out = []\n pos = 0\n length = len(string)\n\n while pos < length - 2:\n if string[pos] == '&' and string[pos + 1] == '#':\n start = pos + 2\n is_hex = False\n first_char = string[start]\n\n if first_char == 'x' or first_char == 'X':\n start += 1\n is_hex = True\n\n if start == length:\n return ''.join(out)\n\n end = start\n while end < length and self.is_hex_char(string[end]):\n end += 1\n\n if end < length and string[end] == ';':\n try:\n entity_value = int(string[start:end], 16 if is_hex else 10)\n except:\n return ''.join(out)\n\n out.append(chr(entity_value))\n pos = end + 1\n continue\n\n out.append(string[pos])\n pos += 1\n\n return ''.join(out)\n\n @staticmethod\n def is_hex_char(char):\n return char.isdigit() or ('a' <= char.lower() <= 'f')", "inputs": ["unescaper = NumericEntityUnescaper()\nres = unescaper.replace(\"ABC\")\nassertEqual(res, \"ABC\")\n", "unescaper = NumericEntityUnescaper()\nres = unescaper.is_hex_char('0')\nassertEqual(res, True)\n"], "outputs": [], "test": "import unittest\n\n\nclass NumericEntityUnescaperTestReplace(unittest.TestCase):\n def test_replace_1(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"ABC\")\n self.assertEqual(res, \"ABC\")\n\n def test_replace_2(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"AAA\")\n self.assertEqual(res, \"AAA\")\n\n def test_replace_3(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"BBB\")\n self.assertEqual(res, \"BBB\")\n\n def test_replace_4(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"CCC\")\n self.assertEqual(res, \"CCC\")\n\n def test_replace_5(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"\")\n self.assertEqual(res, \"\")\n\n def test_replace_6(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#\")\n self.assertEqual(res, \"\")\n\n def test_replace_7(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"eBC\")\n self.assertEqual(res, \"eBC\")\n\n def test_replace_8(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#???;BC\")\n self.assertEqual(res, \"&#???;BC\")\n\n def test_replace_9(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"CCC;\")\n self.assertEqual(res, \"CCC\")\n\n def test_replace_10(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#X\")\n self.assertEqual(res, \"\")\n\n def test_replace_11(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"&#c1d;BC\")\n self.assertEqual(res, \"\")\n\n\nclass NumericEntityUnescaperTestIsHexChar(unittest.TestCase):\n def test_is_hex_char_1(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.is_hex_char('0')\n self.assertEqual(res, True)\n\n def test_is_hex_char_2(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.is_hex_char('F')\n self.assertEqual(res, True)\n\n def test_is_hex_char_3(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.is_hex_char('G')\n self.assertEqual(res, False)\n\n def test_is_hex_char_4(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.is_hex_char('X')\n self.assertEqual(res, False)\n\n def test_is_hex_char_5(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.is_hex_char('Z')\n self.assertEqual(res, False)\n\n\nclass unescaperTest(unittest.TestCase):\n def test_numericentityunescaper(self):\n unescaper = NumericEntityUnescaper()\n res = unescaper.replace(\"ABC\")\n self.assertEqual(res, \"ABC\")\n\n unescaper = NumericEntityUnescaper()\n res = unescaper.is_hex_char('0')\n self.assertEqual(res, True)"} {"task_id": "DREval/132", "entry_point": "Order", "code": "class Order:\n\n def __init__(self):\n self.menu = []\n # menu = [{\"dish\": dish name, \"price\": price, \"count\": count}, ...]\n self.selected_dishes = []\n # selected_dish = {\"dish\": dish name, \"count\": count, price: price}\n self.sales = {}\n # \n\n\n def add_dish(self, dish):\n for menu_dish in self.menu:\n if dish[\"dish\"] == menu_dish[\"dish\"]:\n if menu_dish[\"count\"] < dish[\"count\"]:\n return False\n else:\n menu_dish[\"count\"] -= dish[\"count\"]\n break\n self.selected_dishes.append(dish)\n return True\n\n def calculate_total(self):\n total = 0\n for dish in self.selected_dishes:\n total += dish[\"price\"] * dish[\"count\"] * self.sales[dish[\"dish\"]]\n return total\n\n def checkout(self):\n if len(self.selected_dishes) == 0:\n return False\n total = self.calculate_total()\n self.selected_dishes = []\n return total", "inputs": ["result = self.order.add_dish({\"dish\": \"dish3\", \"price\": 15, \"count\": 4})\nassertTrue(result)\n# test the status of menu and selected_dishes\nmenu = self.order.menu\nfor menu_dish in menu:\n\tif menu_dish[\"dish\"] == \"dish1\":\n\t\tassertEqual(menu_dish[\"count\"], 5)\n\tif menu_dish[\"dish\"] == \"dish2\":\n\t\tassertEqual(menu_dish[\"count\"], 3)\n\tif menu_dish[\"dish\"] == \"dish3\":\n\t\tassertEqual(menu_dish[\"count\"], 3)\nassertEqual(self.order.selected_dishes, [{\"dish\": \"dish3\", \"price\": 15, \"count\": 4}])\n", "self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 2})\nself.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 2})\nresult = self.order.calculate_total()\nassertEqual(50, result)\n", "self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 2})\nself.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 2})\nresult = self.order.checkout()\nassertEqual(50, result)\nmenu = self.order.menu\nfor menu_dish in menu:\n\tif menu_dish[\"dish\"] == \"dish1\":\n\t\tassertEqual(menu_dish[\"count\"], 3)\n\tif menu_dish[\"dish\"] == \"dish2\":\n\t\tassertEqual(menu_dish[\"count\"], 3)\n\tif menu_dish[\"dish\"] == \"dish3\":\n\t\tassertEqual(menu_dish[\"count\"], 5)\nassertEqual([], self.order.selected_dishes)\n", "self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 2})\nself.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 2})\nresult = self.order.checkout()\nassertEqual(50, result)\nmenu = self.order.menu\nfor menu_dish in menu:\n\tif menu_dish[\"dish\"] == \"dish1\":\n\t\tassertEqual(menu_dish[\"count\"], 3)\n\tif menu_dish[\"dish\"] == \"dish2\":\n\t\tassertEqual(menu_dish[\"count\"], 3)\n\tif menu_dish[\"dish\"] == \"dish3\":\n\t\tassertEqual(menu_dish[\"count\"], 5)\nassertEqual([], self.order.selected_dishes)\n"], "outputs": [], "test": "import unittest\n\n\nclass OrderTestAddDish(unittest.TestCase):\n def setUp(self):\n self.order = Order()\n\n self.order.menu.append({\"dish\": \"dish1\", \"price\": 10, \"count\": 5})\n self.order.menu.append({\"dish\": \"dish2\", \"price\": 15, \"count\": 3})\n self.order.menu.append({\"dish\": \"dish3\", \"price\": 20, \"count\": 7})\n self.order.sales = {\"dish1\": 0.9, \"dish2\": 1, \"dish3\": 0.8}\n\n # add dish in menu\n def test_add_dish_1(self):\n result = self.order.add_dish({\"dish\": \"dish3\", \"price\": 15, \"count\": 4})\n self.assertTrue(result)\n\n # test the status of self.menu and self.selected_dishes\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 5)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 3)\n self.assertEqual(self.order.selected_dishes, [{\"dish\": \"dish3\", \"price\": 15, \"count\": 4}])\n\n # add dish when dish count exceeds the remaining count\n def test_add_dish_2(self):\n result = self.order.add_dish({\"dish\": \"dish3\", \"price\": 15, \"count\": 8})\n self.assertFalse(result)\n\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 5)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 7)\n self.assertEqual(self.order.selected_dishes, [])\n\n def test_add_dish_3(self):\n result = self.order.add_dish({\"dish\": \"dish3\", \"price\": 15, \"count\": 7})\n self.assertTrue(result)\n\n # test the status of self.menu and self.selected_dishes\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 5)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 0)\n self.assertEqual(self.order.selected_dishes, [{\"dish\": \"dish3\", \"price\": 15, \"count\": 7}])\n\n def test_add_dish_4(self):\n result = self.order.add_dish({\"dish\": \"dish3\", \"price\": 15, \"count\": 6})\n self.assertTrue(result)\n\n # test the status of self.menu and self.selected_dishes\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 5)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 1)\n self.assertEqual(self.order.selected_dishes, [{\"dish\": \"dish3\", \"price\": 15, \"count\": 6}])\n\n def test_add_dish_5(self):\n result = self.order.add_dish({\"dish\": \"dish3\", \"price\": 15, \"count\": 5})\n self.assertTrue(result)\n\n # test the status of self.menu and self.selected_dishes\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 5)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 2)\n self.assertEqual(self.order.selected_dishes, [{\"dish\": \"dish3\", \"price\": 15, \"count\": 5}])\n\n def test_add_dish_6(self):\n self.order.menu = []\n result = self.order.add_dish({})\n self.assertTrue(result)\n\n\nclass OrderTestCalculateTotal(unittest.TestCase):\n def setUp(self):\n self.order = Order()\n self.order.menu.append({\"dish\": \"dish1\", \"price\": 10, \"count\": 5})\n self.order.menu.append({\"dish\": \"dish2\", \"price\": 15, \"count\": 3})\n self.order.menu.append({\"dish\": \"dish3\", \"price\": 20, \"count\": 7})\n self.order.sales = {\"dish1\": 0.9, \"dish2\": 1, \"dish3\": 0.8}\n\n def test_calculate_total_1(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 2})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 2})\n result = self.order.calculate_total()\n self.assertEqual(50, result)\n\n def test_calculate_total_2(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 2})\n self.order.add_dish({\"dish\": \"dish2\", \"price\": 15, \"count\": 2})\n result = self.order.calculate_total()\n self.assertEqual(48, result)\n\n def test_calculate_total_3(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 1})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 1})\n result = self.order.calculate_total()\n self.assertEqual(25, result)\n\n def test_calculate_total_4(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 3})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 3})\n result = self.order.calculate_total()\n self.assertEqual(75, result)\n\n def test_calculate_total_5(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 4})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 4})\n result = self.order.calculate_total()\n self.assertEqual(100, result)\n\n\nclass OrderTestCheckout(unittest.TestCase):\n def setUp(self):\n self.order = Order()\n self.order.menu.append({\"dish\": \"dish1\", \"price\": 10, \"count\": 5})\n self.order.menu.append({\"dish\": \"dish2\", \"price\": 15, \"count\": 3})\n self.order.menu.append({\"dish\": \"dish3\", \"price\": 20, \"count\": 7})\n self.order.sales = {\"dish1\": 0.9, \"dish2\": 1, \"dish3\": 0.8}\n\n # as test_main\n def test_checkout_1(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 2})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 2})\n result = self.order.checkout()\n self.assertEqual(50, result)\n\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 5)\n self.assertEqual([], self.order.selected_dishes)\n\n # haven't ordered dishes.\n # self.selected_dishes is empty\n def test_checkout_2(self):\n result = self.order.checkout()\n self.assertFalse(result)\n\n def test_checkout_3(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 1})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 1})\n result = self.order.checkout()\n self.assertEqual(25, result)\n\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 4)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 6)\n self.assertEqual([], self.order.selected_dishes)\n\n def test_checkout_4(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 3})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 3})\n result = self.order.checkout()\n self.assertEqual(75, result)\n\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 2)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 4)\n self.assertEqual([], self.order.selected_dishes)\n\n def test_checkout_5(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 5})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 5})\n result = self.order.checkout()\n self.assertEqual(125, result)\n\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 0)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 2)\n self.assertEqual([], self.order.selected_dishes)\n\n\nclass OrderTest(unittest.TestCase):\n def setUp(self):\n self.order = Order()\n\n self.order.menu.append({\"dish\": \"dish1\", \"price\": 10, \"count\": 5})\n self.order.menu.append({\"dish\": \"dish2\", \"price\": 15, \"count\": 3})\n self.order.menu.append({\"dish\": \"dish3\", \"price\": 20, \"count\": 7})\n self.order.sales = {\"dish1\": 0.9, \"dish2\": 1, \"dish3\": 0.8}\n\n def test_order(self):\n self.order.add_dish({\"dish\": \"dish1\", \"price\": 10, \"count\": 2})\n self.order.add_dish({\"dish\": \"dish3\", \"price\": 20, \"count\": 2})\n result = self.order.checkout()\n self.assertEqual(50, result)\n\n menu = self.order.menu\n for menu_dish in menu:\n if menu_dish[\"dish\"] == \"dish1\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish2\":\n self.assertEqual(menu_dish[\"count\"], 3)\n if menu_dish[\"dish\"] == \"dish3\":\n self.assertEqual(menu_dish[\"count\"], 5)\n self.assertEqual([], self.order.selected_dishes)"} {"task_id": "DREval/133", "entry_point": "PageUtil", "code": "class PageUtil:\n def __init__(self, data, page_size):\n self.data = data\n self.page_size = page_size\n self.total_items = len(data)\n self.total_pages = (self.total_items + page_size - 1) // page_size\n\n def get_page(self, page_number):\n if page_number < 1 or page_number > self.total_pages:\n return []\n\n start_index = (page_number - 1) * self.page_size\n end_index = start_index + self.page_size\n return self.data[start_index:end_index]\n\n def get_page_info(self, page_number):\n if page_number < 1 or page_number > self.total_pages:\n return {}\n\n start_index = (page_number - 1) * self.page_size\n end_index = min(start_index + self.page_size, self.total_items)\n page_data = self.data[start_index:end_index]\n\n page_info = {\n \"current_page\": page_number,\n \"per_page\": self.page_size,\n \"total_pages\": self.total_pages,\n \"total_items\": self.total_items,\n \"has_previous\": page_number > 1,\n \"has_next\": page_number < self.total_pages,\n \"data\": page_data\n }\n return page_info\n\n def search(self, keyword):\n results = [item for item in self.data if keyword in str(item)]\n num_results = len(results)\n num_pages = (num_results + self.page_size - 1) // self.page_size\n\n search_info = {\n \"keyword\": keyword,\n \"total_results\": num_results,\n \"total_pages\": num_pages,\n \"results\": results\n }\n return search_info", "inputs": ["page_number = 1\nexpected_page = [1, 2, 3]\nactual_page = self.page_util.get_page(page_number)\nassertEqual(actual_page, expected_page)\n", "page_number = 2\nexpected_info = {\n\"current_page\": 2,\n\"per_page\": 3,\n\"total_pages\": 4,\n\"total_items\": 10,\n\"has_previous\": True,\n\"has_next\": True,\n\"data\": [4, 5, 6]\n}\nactual_info = self.page_util.get_page_info(page_number)\nassertEqual(actual_info, expected_info)\n", "keyword = \"1\"\nexpected_results = {\n\"keyword\": \"1\",\n\"total_results\": 2,\n\"total_pages\": 1,\n\"results\": [1, 10]\n}\nactual_results = self.page_util.search(keyword)\nassertEqual(actual_results, expected_results)\n", "page_number = 1\nexpected_page = [1, 2, 3]\nactual_page = self.page_util.get_page(page_number)\nassertEqual(actual_page, expected_page)\npage_number = 2\nexpected_info = {\n\"current_page\": 2,\n\"per_page\": 3,\n\"total_pages\": 4,\n\"total_items\": 10,\n\"has_previous\": True,\n\"has_next\": True,\n\"data\": [4, 5, 6]\n}\nactual_info = self.page_util.get_page_info(page_number)\nassertEqual(actual_info, expected_info)\nkeyword = \"4\"\nexpected_results = {\n\"keyword\": \"4\",\n\"total_results\": 1,\n\"total_pages\": 1,\n\"results\": [4]\n}\nactual_results = self.page_util.search(keyword)\nassertEqual(actual_results, expected_results)\n"], "outputs": [], "test": "import unittest\n\n\nclass PageUtilTestGetPage(unittest.TestCase):\n def setUp(self):\n self.data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n self.page_size = 3\n self.page_util = PageUtil(self.data, self.page_size)\n\n def test_get_page_1(self):\n page_number = 1\n expected_page = [1, 2, 3]\n actual_page = self.page_util.get_page(page_number)\n self.assertEqual(actual_page, expected_page)\n\n def test_get_page_2(self):\n page_number = 2\n expected_page = [4, 5, 6]\n actual_page = self.page_util.get_page(page_number)\n self.assertEqual(actual_page, expected_page)\n\n def test_get_page_3(self):\n page_number = 3\n expected_page = [7, 8, 9]\n actual_page = self.page_util.get_page(page_number)\n self.assertEqual(actual_page, expected_page)\n\n def test_get_page_4(self):\n page_number = 4\n expected_page = [10]\n actual_page = self.page_util.get_page(page_number)\n self.assertEqual(actual_page, expected_page)\n\n def test_get_page_5(self):\n invalid_page_number = 0\n empty_page = []\n actual_page = self.page_util.get_page(invalid_page_number)\n self.assertEqual(actual_page, empty_page)\n\n\nclass PageUtilTestGetPageInfo(unittest.TestCase):\n def setUp(self):\n self.data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n self.page_size = 3\n self.page_util = PageUtil(self.data, self.page_size)\n\n def test_get_page_info_1(self):\n page_number = 2\n expected_info = {\n \"current_page\": 2,\n \"per_page\": 3,\n \"total_pages\": 4,\n \"total_items\": 10,\n \"has_previous\": True,\n \"has_next\": True,\n \"data\": [4, 5, 6]\n }\n actual_info = self.page_util.get_page_info(page_number)\n self.assertEqual(actual_info, expected_info)\n\n def test_get_page_info_2(self):\n page_number = 1\n expected_info = {\n \"current_page\": 1,\n \"per_page\": 3,\n \"total_pages\": 4,\n \"total_items\": 10,\n \"has_previous\": False,\n \"has_next\": True,\n \"data\": [1, 2, 3]\n }\n actual_info = self.page_util.get_page_info(page_number)\n self.assertEqual(actual_info, expected_info)\n\n def test_get_page_info_3(self):\n page_number = 3\n expected_info = {\n \"current_page\": 3,\n \"per_page\": 3,\n \"total_pages\": 4,\n \"total_items\": 10,\n \"has_previous\": True,\n \"has_next\": True,\n \"data\": [7, 8, 9]\n }\n actual_info = self.page_util.get_page_info(page_number)\n self.assertEqual(actual_info, expected_info)\n\n def test_get_page_info_4(self):\n page_number = 4\n expected_info = {\n \"current_page\": 4,\n \"per_page\": 3,\n \"total_pages\": 4,\n \"total_items\": 10,\n \"has_previous\": True,\n \"has_next\": False,\n \"data\": [10]\n }\n actual_info = self.page_util.get_page_info(page_number)\n self.assertEqual(actual_info, expected_info)\n\n def test_get_page_info_5(self):\n invalid_page_number = 5\n empty_info = {}\n actual_info = self.page_util.get_page_info(invalid_page_number)\n self.assertEqual(actual_info, empty_info)\n\n\nclass PageUtilTestSearch(unittest.TestCase):\n def setUp(self):\n self.data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n self.page_size = 3\n self.page_util = PageUtil(self.data, self.page_size)\n\n def test_search_1(self):\n keyword = \"1\"\n expected_results = {\n \"keyword\": \"1\",\n \"total_results\": 2,\n \"total_pages\": 1,\n \"results\": [1, 10]\n }\n actual_results = self.page_util.search(keyword)\n self.assertEqual(actual_results, expected_results)\n\n def test_search_2(self):\n keyword = \"2\"\n expected_results = {\n \"keyword\": \"2\",\n \"total_results\": 1,\n \"total_pages\": 1,\n \"results\": [2]\n }\n actual_results = self.page_util.search(keyword)\n self.assertEqual(actual_results, expected_results)\n\n def test_search_3(self):\n keyword = \"3\"\n expected_results = {\n \"keyword\": \"3\",\n \"total_results\": 1,\n \"total_pages\": 1,\n \"results\": [3]\n }\n actual_results = self.page_util.search(keyword)\n self.assertEqual(actual_results, expected_results)\n\n def test_search_4(self):\n keyword = \"4\"\n expected_results = {\n \"keyword\": \"4\",\n \"total_results\": 1,\n \"total_pages\": 1,\n \"results\": [4]\n }\n actual_results = self.page_util.search(keyword)\n self.assertEqual(actual_results, expected_results)\n\n def test_search_5(self):\n keyword = \"11\"\n expected_results = {\n \"keyword\": \"11\",\n \"total_results\": 0,\n \"total_pages\": 0,\n \"results\": []\n }\n actual_results = self.page_util.search(keyword)\n self.assertEqual(actual_results, expected_results)\n\n\nclass PageUtilTest(unittest.TestCase):\n def setUp(self):\n self.data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n self.page_size = 3\n self.page_util = PageUtil(self.data, self.page_size)\n\n def test_pageutil(self):\n page_number = 1\n expected_page = [1, 2, 3]\n actual_page = self.page_util.get_page(page_number)\n self.assertEqual(actual_page, expected_page)\n\n page_number = 2\n expected_info = {\n \"current_page\": 2,\n \"per_page\": 3,\n \"total_pages\": 4,\n \"total_items\": 10,\n \"has_previous\": True,\n \"has_next\": True,\n \"data\": [4, 5, 6]\n }\n actual_info = self.page_util.get_page_info(page_number)\n self.assertEqual(actual_info, expected_info)\n\n keyword = \"4\"\n expected_results = {\n \"keyword\": \"4\",\n \"total_results\": 1,\n \"total_pages\": 1,\n \"results\": [4]\n }\n actual_results = self.page_util.search(keyword)\n self.assertEqual(actual_results, expected_results)"} {"task_id": "DREval/134", "entry_point": "PersonRequest", "code": "class PersonRequest:\n def __init__(self, name: str, sex: str, phoneNumber: str):\n self.name = self._validate_name(name)\n self.sex = self._validate_sex(sex)\n self.phoneNumber = self._validate_phoneNumber(phoneNumber)\n\n def _validate_name(self, name: str) -> str:\n if not name:\n return None\n if len(name) > 33:\n return None\n return name\n\n def _validate_sex(self, sex: str) -> str:\n if sex not in [\"Man\", \"Woman\", \"UGM\"]:\n return None\n return sex\n\n def _validate_phoneNumber(self, phoneNumber: str) -> str:\n if not phoneNumber:\n return None\n if len(phoneNumber) != 11 or not phoneNumber.isdigit():\n return None\n return phoneNumber", "inputs": ["pr = PersonRequest(\"\", \"Man\", \"12345678901\")\nassertIsNone(pr.name)\n", "pr = PersonRequest(\"John Doe\", \"Unknown\", \"12345678901\")\nassertIsNone(pr.sex)\n", "pr = PersonRequest(\"John Doe\", \"Man\", \"\")\nassertIsNone(pr.phoneNumber)\n", "pr = PersonRequest(\"\", \"Man\", \"12345678901\")\nassertIsNone(pr.name)\npr = PersonRequest(\"John Doe\", \"Unknown\", \"12345678901\")\nassertIsNone(pr.sex)\npr = PersonRequest(\"John Doe\", \"Man\", \"\")\nassertIsNone(pr.phoneNumber)\n"], "outputs": [], "test": "import unittest\n\n\nclass PersonRequestTestValidateName(unittest.TestCase):\n def test_validate_name_1(self):\n pr = PersonRequest(\"\", \"Man\", \"12345678901\")\n self.assertIsNone(pr.name)\n\n def test_validate_name_2(self):\n pr = PersonRequest(\"This is a very long name that exceeds the character limit\", \"Man\",\n \"12345678901\")\n self.assertIsNone(pr.name)\n\n def test_validate_name_3(self):\n pr = PersonRequest(\"aaa\", \"Man\", \"12345678901\")\n self.assertEqual(pr.name, 'aaa')\n\n def test_validate_name_4(self):\n pr = PersonRequest(\"bbb\", \"Man\", \"12345678901\")\n self.assertEqual(pr.name, 'bbb')\n\n def test_validate_name_5(self):\n pr = PersonRequest(\"ccc\", \"Man\", \"12345678901\")\n self.assertEqual(pr.name, 'ccc')\n\n\nclass PersonRequestTestValidateSex(unittest.TestCase):\n def test_validate_sex_1(self):\n pr = PersonRequest(\"John Doe\", \"Unknown\", \"12345678901\")\n self.assertIsNone(pr.sex)\n\n def test_validate_sex_2(self):\n pr = PersonRequest(\"John Doe\", \"UGM\", \"12345678901\")\n self.assertEqual(pr.sex, \"UGM\")\n\n def test_validate_sex_3(self):\n pr = PersonRequest(\"John Doe\", \"Man\", \"12345678901\")\n self.assertEqual(pr.sex, \"Man\")\n\n def test_validate_sex_4(self):\n pr = PersonRequest(\"John Doe\", \"Woman\", \"12345678901\")\n self.assertEqual(pr.sex, \"Woman\")\n\n def test_validate_sex_5(self):\n pr = PersonRequest(\"John Doe\", \"khsigy\", \"12345678901\")\n self.assertIsNone(pr.sex)\n\n\nclass PersonRequestTestValidatePhoneNumber(unittest.TestCase):\n def test_validate_phoneNumber_1(self):\n pr = PersonRequest(\"John Doe\", \"Man\", \"\")\n self.assertIsNone(pr.phoneNumber)\n\n def test_validate_phoneNumber_2(self):\n pr = PersonRequest(\"John Doe\", \"Man\", \"12345\")\n self.assertIsNone(pr.phoneNumber)\n\n def test_validate_phoneNumber_3(self):\n pr = PersonRequest(\"John Doe\", \"Man\", \"jgdjrj\")\n self.assertIsNone(pr.phoneNumber)\n\n def test_validate_phoneNumber_4(self):\n pr = PersonRequest(\"John Doe\", \"Man\", \"12345678901\")\n self.assertEqual(pr.phoneNumber, \"12345678901\")\n\n def test_validate_phoneNumber_5(self):\n pr = PersonRequest(\"John Doe\", \"Man\", \"11111111111\")\n self.assertEqual(pr.phoneNumber, \"11111111111\")\n\n\nclass PersonRequestTest(unittest.TestCase):\n def test_PersonRequest(self):\n pr = PersonRequest(\"\", \"Man\", \"12345678901\")\n self.assertIsNone(pr.name)\n\n pr = PersonRequest(\"John Doe\", \"Unknown\", \"12345678901\")\n self.assertIsNone(pr.sex)\n\n pr = PersonRequest(\"John Doe\", \"Man\", \"\")\n self.assertIsNone(pr.phoneNumber)"} {"task_id": "DREval/135", "entry_point": "PushBoxGame", "code": "class PushBoxGame:\n def __init__(self, map):\n self.map = map\n self.player_row = 0\n self.player_col = 0\n self.targets = []\n self.boxes = []\n self.target_count = 0\n self.is_game_over = False\n\n self.init_game()\n\n def init_game(self):\n for row in range(len(self.map)):\n for col in range(len(self.map[row])):\n if self.map[row][col] == \"O\":\n self.player_row = row\n self.player_col = col\n elif self.map[row][col] == \"G\":\n self.targets.append((row, col))\n self.target_count += 1\n elif self.map[row][col] == \"X\":\n self.boxes.append((row, col))\n\n def check_win(self):\n box_on_target_count = 0\n for box in self.boxes:\n if box in self.targets:\n box_on_target_count += 1\n if box_on_target_count == self.target_count:\n self.is_game_over = True\n return self.is_game_over\n\n def move(self, direction):\n new_player_row = self.player_row\n new_player_col = self.player_col\n\n if direction == \"w\":\n new_player_row -= 1\n elif direction == \"s\":\n new_player_row += 1\n elif direction == \"a\":\n new_player_col -= 1\n elif direction == \"d\":\n new_player_col += 1\n\n if self.map[new_player_row][new_player_col] != \"#\":\n if (new_player_row, new_player_col) in self.boxes:\n new_box_row = new_player_row + (new_player_row - self.player_row)\n new_box_col = new_player_col + (new_player_col - self.player_col)\n\n if self.map[new_box_row][new_box_col] != \"#\":\n self.boxes.remove((new_player_row, new_player_col))\n self.boxes.append((new_box_row, new_box_col))\n self.player_row = new_player_row\n self.player_col = new_player_col\n else:\n self.player_row = new_player_row\n self.player_col = new_player_col\n\n return self.check_win()", "inputs": ["assertEqual(self.game.map, self.game_map)\n", "assertFalse(self.game.check_win())\n", "moves = ['d', 's', 'a', 's']\nfor move in moves:\n\tassertFalse(self.game.move(move))\nassertTrue(self.game.move('d'))\n"], "outputs": [], "test": "import unittest\n\n\nclass PushBoxGameTestInitGame(unittest.TestCase):\n def setUp(self) -> None:\n self.game_map = [\n \"#####\",\n \"#O #\",\n \"# X #\",\n \"# G#\",\n \"#####\"\n ]\n self.game = PushBoxGame(self.game_map)\n\n def test_init_game_1(self):\n self.assertEqual(self.game.map, self.game_map)\n\n def test_init_game_2(self):\n self.assertEqual(self.game.is_game_over, False)\n\n def test_init_game_3(self):\n self.assertEqual(self.game.player_col, 1)\n\n def test_init_game_4(self):\n self.assertEqual(self.game.player_row, 1)\n\n def test_init_game_5(self):\n self.assertEqual(self.game.targets, [(3, 3)])\n\n def test_init_game_6(self):\n self.assertEqual(self.game.boxes, [(2, 2)])\n\n def test_init_game_7(self):\n self.assertEqual(self.game.target_count, 1)\n\n\nclass PushBoxGameTestCheckWin(unittest.TestCase):\n def setUp(self) -> None:\n self.game_map = [\n \"#####\",\n \"#O #\",\n \"# X #\",\n \"# G#\",\n \"#####\"\n ]\n self.game = PushBoxGame(self.game_map)\n\n def test_check_win_1(self):\n self.assertFalse(self.game.check_win())\n\n def test_check_win_2(self):\n moves = ['d', 's', 'a', 's', 'd']\n for move in moves:\n self.game.move(move)\n self.assertTrue(self.game.check_win())\n\nclass PushBoxGameTestMove(unittest.TestCase):\n def setUp(self) -> None:\n self.game_map = [\n \"#####\",\n \"#O #\",\n \"# X #\",\n \"# G#\",\n \"#####\"\n ]\n self.game = PushBoxGame(self.game_map)\n\n def test_move_1(self):\n moves = ['d', 's', 'a', 's']\n for move in moves:\n self.assertFalse(self.game.move(move))\n self.assertTrue(self.game.move('d'))\n\n def test_move_2(self):\n self.game.move('a')\n self.assertEqual(self.game.player_col, 1)\n self.assertEqual(self.game.player_row, 1)\n self.assertFalse(self.game.is_game_over)\n\n def test_move_3(self):\n self.game.move('d')\n self.assertEqual(self.game.player_col, 2)\n self.assertEqual(self.game.player_row, 1)\n self.assertFalse(self.game.is_game_over)\n\n def test_move_4(self):\n self.game.move('s')\n self.assertEqual(self.game.player_col, 1)\n self.assertEqual(self.game.player_row, 2)\n self.assertFalse(self.game.is_game_over)\n\n def test_move_5(self):\n self.game.move('w')\n self.assertEqual(self.game.player_col, 1)\n self.assertEqual(self.game.player_row, 1)\n self.assertFalse(self.game.is_game_over)\n\n def test_move_6(self):\n self.game.move('?')\n self.assertFalse(self.game.is_game_over)\n\n def test_move_7(self):\n self.game_map = [\n \"#####\",\n \"# X #\",\n \"# O #\",\n \"# G#\",\n \"#####\"\n ]\n self.game = PushBoxGame(self.game_map)\n self.game.move('w')\n self.assertEqual(self.game.player_col, 2)\n self.assertEqual(self.game.player_row, 2)\n self.assertFalse(self.game.is_game_over)"} {"task_id": "DREval/136", "entry_point": "RPGCharacter", "code": "class RPGCharacter:\n def __init__(self, name, hp, attack_power, defense, level=1):\n self.name = name\n self.hp = hp\n self.attack_power = attack_power\n self.defense = defense\n self.level = level\n self.exp = 0\n\n def attack(self, other_character):\n damage = max(self.attack_power - other_character.defense, 1)\n other_character.hp -= damage\n\n def heal(self):\n self.hp += 10\n if self.hp > 100:\n self.hp = 100\n return self.hp\n\n def gain_exp(self, amount):\n while amount != 0:\n if self.exp + amount >= self.level * 100:\n amount -= (self.level * 100 - self.exp)\n self.level_up()\n else:\n self.exp += amount\n amount = 0\n\n def level_up(self):\n if self.level < 100:\n self.level += 1\n self.exp = 0\n self.hp += 20\n self.attack_power += 5\n self.defense += 5\n return self.level, self.hp, self.attack_power, self.defense\n\n def is_alive(self):\n return self.hp > 0", "inputs": ["character1 = RPGCharacter(\"John\", 100, 20, 10)\ncharacter2 = RPGCharacter(\"Enemy\", 100, 15, 5)\ncharacter1.attack(character2)\nassertEqual(character2.hp, 85)\n", "character = RPGCharacter(\"John\", 90, 20, 10)\ncharacter.heal()\nassertEqual(character.hp, 100)\n", "character = RPGCharacter(\"John\", 100, 20, 10)\ncharacter.gain_exp(100)\nassertEqual(character.level, 2)\nassertEqual(character.exp, 0)\n", "character = RPGCharacter(\"John\", 100, 20, 10)\ncharacter.level_up()\nassertEqual(character.level, 2)\nassertEqual(character.exp, 0)\nassertEqual(character.hp, 120)\nassertEqual(character.attack_power, 25)\nassertEqual(character.defense, 15)\n", "character = RPGCharacter(\"John\", 100, 20, 10)\nassertTrue(character.is_alive())\n", "character1 = RPGCharacter(\"John\", 100, 20, 10)\ncharacter2 = RPGCharacter(\"Enemy\", 100, 15, 5)\ncharacter1.attack(character2)\nassertEqual(character2.hp, 85)\ncharacter2.heal()\nassertEqual(character2.hp, 95)\ncharacter1.gain_exp(200)\nassertEqual(character1.exp, 100)\nassertEqual(character1.hp, 120)\nassertEqual(character1.attack_power, 25)\nassertEqual(character1.defense, 15)\nassertTrue(character1.is_alive())\n"], "outputs": [], "test": "import unittest\n\nclass RPGCharacterTestAttack(unittest.TestCase):\n def test_attack(self):\n character1 = RPGCharacter(\"John\", 100, 20, 10)\n character2 = RPGCharacter(\"Enemy\", 100, 15, 5)\n character1.attack(character2)\n self.assertEqual(character2.hp, 85)\n\n def test_attack_2(self):\n character1 = RPGCharacter(\"John\", 100, 20, 10)\n character2 = RPGCharacter(\"Enemy\", 100, 15, 5)\n character2.attack(character1)\n self.assertEqual(character1.hp, 95)\n\n def test_attack_3(self):\n character1 = RPGCharacter(\"John\", 100, 20, 10)\n character2 = RPGCharacter(\"Enemy\", 100, 15, 5)\n character1.attack(character2)\n character2.attack(character1)\n self.assertEqual(character1.hp, 95)\n self.assertEqual(character2.hp, 85)\n\n def test_attack_4(self):\n character1 = RPGCharacter(\"John\", 100, 20, 10)\n character2 = RPGCharacter(\"Enemy\", 100, 15, 5)\n character1.attack(character2)\n character1.attack(character2)\n self.assertEqual(character2.hp, 70)\n\n def test_attack_5(self):\n character1 = RPGCharacter(\"John\", 100, 20, 10)\n character2 = RPGCharacter(\"Enemy\", 100, 15, 5)\n character1.attack(character2)\n character1.attack(character2)\n character1.attack(character2)\n self.assertEqual(character2.hp, 55)\n\nclass RPGCharacterTestHeal(unittest.TestCase):\n def test_heal_1(self):\n character = RPGCharacter(\"John\", 90, 20, 10)\n character.heal()\n self.assertEqual(character.hp, 100)\n\n # overflow healing \n def test_heal_2(self):\n character = RPGCharacter(\"John\", 97, 20, 10)\n character.heal()\n self.assertEqual(character.hp, 100)\n\n def test_heal_3(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.heal()\n self.assertEqual(character.hp, 100)\n\n def test_heal_4(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.hp = 50\n character.heal()\n self.assertEqual(character.hp, 60)\n\n def test_heal_5(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.hp = 10\n character.heal()\n self.assertEqual(character.hp, 20)\n\n\nclass RPGCharacterTestGainExp(unittest.TestCase):\n\n # exp not overflow\n def test_gain_exp_1(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.gain_exp(100)\n self.assertEqual(character.level, 2)\n self.assertEqual(character.exp, 0)\n\n # exp overflow\n def test_gain_exp_2(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.gain_exp(1100)\n self.assertEqual(character.level, 5)\n self.assertEqual(character.exp, 100)\n\n def test_gain_exp_3(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.gain_exp(200)\n self.assertEqual(character.level, 2)\n self.assertEqual(character.exp, 100)\n\n def test_gain_exp_4(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.gain_exp(300)\n self.assertEqual(character.level, 3)\n self.assertEqual(character.exp, 0)\n\n def test_gain_exp_5(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.gain_exp(400)\n self.assertEqual(character.level, 3)\n self.assertEqual(character.exp, 100)\n\n\nclass RPGCharacterTestLevelUp(unittest.TestCase):\n def test_level_up_1(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n character.level_up()\n self.assertEqual(character.level, 2)\n self.assertEqual(character.exp, 0)\n self.assertEqual(character.hp, 120)\n self.assertEqual(character.attack_power, 25)\n self.assertEqual(character.defense, 15)\n\n # full level\n def test_level_up_2(self):\n character = RPGCharacter(\"John\", 100, 20, 10, 100)\n character.level_up()\n self.assertEqual(character.level, 100)\n self.assertEqual(character.exp, 0)\n self.assertEqual(character.hp, 100)\n self.assertEqual(character.attack_power, 20)\n self.assertEqual(character.defense, 10)\n\n def test_level_up_3(self):\n character = RPGCharacter(\"John\", 100, 20, 10, 2)\n character.level_up()\n self.assertEqual(character.level, 3)\n self.assertEqual(character.exp, 0)\n self.assertEqual(character.hp, 120)\n self.assertEqual(character.attack_power, 25)\n self.assertEqual(character.defense, 15)\n\n def test_level_up_4(self):\n character = RPGCharacter(\"John\", 100, 20, 10, 3)\n character.level_up()\n self.assertEqual(character.level, 4)\n self.assertEqual(character.exp, 0)\n self.assertEqual(character.hp, 120)\n self.assertEqual(character.attack_power, 25)\n self.assertEqual(character.defense, 15)\n\n def test_level_up_5(self):\n character = RPGCharacter(\"John\", 100, 20, 10, 4)\n character.level_up()\n self.assertEqual(character.level, 5)\n self.assertEqual(character.exp, 0)\n self.assertEqual(character.hp, 120)\n self.assertEqual(character.attack_power, 25)\n self.assertEqual(character.defense, 15)\n\n\nclass RPGCharacterTestIsAlive(unittest.TestCase):\n def test_is_alive_1(self):\n character = RPGCharacter(\"John\", 100, 20, 10)\n self.assertTrue(character.is_alive())\n\n def test_is_alive_2(self):\n character = RPGCharacter(\"John\", 0, 20, 10)\n self.assertFalse(character.is_alive())\n\n def test_is_alive_3(self):\n character = RPGCharacter(\"John\", -10, 20, 10)\n self.assertFalse(character.is_alive())\n\n def test_is_alive_4(self):\n character = RPGCharacter(\"John\", 1, 20, 10)\n self.assertTrue(character.is_alive())\n\n def test_is_alive_5(self):\n character = RPGCharacter(\"John\", 10, 20, 10)\n self.assertTrue(character.is_alive())\n\nclass RPGCharacterTestMain(unittest.TestCase):\n def test_main(self):\n character1 = RPGCharacter(\"John\", 100, 20, 10)\n character2 = RPGCharacter(\"Enemy\", 100, 15, 5)\n character1.attack(character2)\n self.assertEqual(character2.hp, 85)\n character2.heal()\n self.assertEqual(character2.hp, 95)\n character1.gain_exp(200)\n self.assertEqual(character1.exp, 100)\n self.assertEqual(character1.hp, 120)\n self.assertEqual(character1.attack_power, 25)\n self.assertEqual(character1.defense, 15)\n self.assertTrue(character1.is_alive())"} {"task_id": "DREval/137", "entry_point": "Server", "code": "class Server:\n\n def __init__(self):\n self.white_list = []\n self.send_struct = {}\n self.receive_struct = {}\n\n def add_white_list(self, addr):\n if addr in self.white_list:\n return False\n else:\n self.white_list.append(addr)\n return self.white_list\n\n def del_white_list(self, addr):\n if addr not in self.white_list:\n return False\n else:\n self.white_list.remove(addr)\n return self.white_list\n\n def recv(self, info):\n if not isinstance(info, dict) or \"addr\" not in info or \"content\" not in info:\n return -1\n addr = info[\"addr\"]\n content = info[\"content\"]\n if addr not in self.white_list:\n return False\n else:\n self.receive_struct = {\"addr\": addr, \"content\": content}\n return self.receive_struct[\"content\"]\n\n def send(self, info):\n if not isinstance(info, dict) or \"addr\" not in info or \"content\" not in info:\n return \"info structure is not correct\"\n self.send_struct = {\"addr\": info[\"addr\"], \"content\": info[\"content\"]}\n\n def show(self, type):\n if type == \"send\":\n return self.send_struct\n elif type == \"receive\":\n return self.receive_struct\n else:\n return False", "inputs": ["server = Server()\nserver.add_white_list(88)\nassertEqual(server.white_list, [88])\n", "server = Server()\nserver.add_white_list(88)\nserver.del_white_list(88)\nassertEqual(server.white_list, [])\n", "server = Server()\nserver.add_white_list(88)\nserver.recv({\"addr\": 88, \"content\": \"abc\"})\nassertEqual(server.receive_struct, {\"addr\": 88, \"content\": \"abc\"})\n", "server = Server()\nserver.send({\"addr\": 88, \"content\": \"abc\"})\nassertEqual(server.send_struct, {\"addr\": 88, \"content\": \"abc\"})\n", "server = Server()\nserver.add_white_list(66)\nserver.send({\"addr\": 88, \"content\": \"abc\"})\nserver.recv({\"addr\": 66, \"content\": \"ABC\"})\nassertEqual(server.show(\"send\"), {\"addr\": 88, \"content\": \"abc\"})\n", "server = Server()\nserver.add_white_list(88)\nassertEqual(server.white_list, [88])\nserver.del_white_list(88)\nassertEqual(server.white_list, [])\nserver.add_white_list(88)\nserver.recv({\"addr\": 88, \"content\": \"abc\"})\nassertEqual(server.receive_struct, {\"addr\": 88, \"content\": \"abc\"})\nserver.send({\"addr\": 66, \"content\": \"ABC\"})\nassertEqual(server.send_struct, {\"addr\": 66, \"content\": \"ABC\"})\nserver.recv({\"addr\": 88, \"content\": \"abc\"})\nassertEqual(server.show(\"receive\"), {\"addr\": 88, \"content\": \"abc\"})\n"], "outputs": [], "test": "import unittest\n\n\nclass ServerTestAddWhiteList(unittest.TestCase):\n def test_add_white_list_1(self):\n server = Server()\n server.add_white_list(88)\n self.assertEqual(server.white_list, [88])\n\n def test_add_white_list_2(self):\n server = Server()\n server.add_white_list(88)\n self.assertEqual(server.add_white_list(88), False)\n\n def test_add_white_list_3(self):\n server = Server()\n server.add_white_list(88)\n server.add_white_list(11)\n self.assertEqual(server.add_white_list(11), False)\n\n def test_add_white_list_4(self):\n server = Server()\n server.add_white_list(11)\n self.assertEqual(server.white_list, [11])\n\n def test_add_white_list_5(self):\n server = Server()\n server.add_white_list(88)\n server.add_white_list(11)\n server.add_white_list(22)\n self.assertEqual(server.add_white_list(22), False)\n\n\nclass ServerTestDelWhiteList(unittest.TestCase):\n def test_del_white_list_1(self):\n server = Server()\n server.add_white_list(88)\n server.del_white_list(88)\n self.assertEqual(server.white_list, [])\n\n def test_del_white_list_2(self):\n server = Server()\n self.assertEqual(server.del_white_list(88), False)\n\n def test_del_white_list_3(self):\n server = Server()\n self.assertEqual(server.del_white_list(11), False)\n\n def test_del_white_list_4(self):\n server = Server()\n self.assertEqual(server.del_white_list(22), False)\n\n def test_del_white_list_5(self):\n server = Server()\n server.add_white_list(11)\n self.assertEqual(server.del_white_list(22), False)\n\n\nclass ServerTestRecv(unittest.TestCase):\n def test_recv_1(self):\n server = Server()\n server.add_white_list(88)\n server.recv({\"addr\": 88, \"content\": \"abc\"})\n self.assertEqual(server.receive_struct, {\"addr\": 88, \"content\": \"abc\"})\n\n def test_recv_2(self):\n server = Server()\n server.add_white_list(88)\n flag = server.recv({\"addr\": 66, \"content\": \"abc\"})\n self.assertEqual(server.receive_struct, {})\n self.assertEqual(flag, False)\n\n def test_recv_3(self):\n server = Server()\n flag = server.recv([88])\n self.assertEqual(server.receive_struct, {})\n self.assertEqual(flag, -1)\n\n def test_recv_4(self):\n server = Server()\n flag = server.recv({\"addr\": 88})\n self.assertEqual(server.receive_struct, {})\n self.assertEqual(flag, -1)\n\n def test_recv_5(self):\n server = Server()\n flag = server.recv({\"content\": \"abc\"})\n self.assertEqual(server.receive_struct, {})\n self.assertEqual(flag, -1)\n\n\nclass ServerTestSend(unittest.TestCase):\n def test_send_1(self):\n server = Server()\n server.send({\"addr\": 88, \"content\": \"abc\"})\n self.assertEqual(server.send_struct, {\"addr\": 88, \"content\": \"abc\"})\n\n def test_send_2(self):\n server = Server()\n flag = server.send({\"addr\": 88})\n self.assertEqual(flag, \"info structure is not correct\")\n\n def test_send_3(self):\n server = Server()\n flag = server.send({\"content\": \"abc\"})\n self.assertEqual(flag, \"info structure is not correct\")\n\n def test_send_4(self):\n server = Server()\n flag = server.send([])\n self.assertEqual(flag, \"info structure is not correct\")\n\n def test_send_5(self):\n server = Server()\n server.send({\"addr\": 66, \"content\": \"abc\"})\n self.assertEqual(server.send_struct, {\"addr\": 66, \"content\": \"abc\"})\n\n\nclass ServerTestShow(unittest.TestCase):\n def test_show_1(self):\n server = Server()\n server.add_white_list(66)\n server.send({\"addr\": 88, \"content\": \"abc\"})\n server.recv({\"addr\": 66, \"content\": \"ABC\"})\n self.assertEqual(server.show(\"send\"), {\"addr\": 88, \"content\": \"abc\"})\n\n def test_show_2(self):\n server = Server()\n server.add_white_list(66)\n server.send({\"addr\": 88, \"content\": \"abc\"})\n server.recv({\"addr\": 66, \"content\": \"ABC\"})\n self.assertEqual(server.show(\"receive\"), {\"addr\": 66, \"content\": \"ABC\"})\n\n def test_show_3(self):\n server = Server()\n server.add_white_list(66)\n server.send({\"addr\": 88, \"content\": \"abc\"})\n server.recv({\"addr\": 66, \"content\": \"ABC\"})\n self.assertEqual(server.show(\"abcdefg\"), False)\n\n def test_show_4(self):\n server = Server()\n server.add_white_list(66)\n server.send({\"addr\": 11, \"content\": \"abc\"})\n server.recv({\"addr\": 66, \"content\": \"ABC\"})\n self.assertEqual(server.show(\"send\"), {\"addr\": 11, \"content\": \"abc\"})\n\n def test_show_5(self):\n server = Server()\n server.add_white_list(66)\n server.send({\"addr\": 22, \"content\": \"abc\"})\n server.recv({\"addr\": 66, \"content\": \"ABC\"})\n self.assertEqual(server.show(\"send\"), {\"addr\": 22, \"content\": \"abc\"})\n\n\nclass ServerTest(unittest.TestCase):\n def test_server(self):\n server = Server()\n server.add_white_list(88)\n self.assertEqual(server.white_list, [88])\n server.del_white_list(88)\n self.assertEqual(server.white_list, [])\n server.add_white_list(88)\n server.recv({\"addr\": 88, \"content\": \"abc\"})\n self.assertEqual(server.receive_struct, {\"addr\": 88, \"content\": \"abc\"})\n server.send({\"addr\": 66, \"content\": \"ABC\"})\n self.assertEqual(server.send_struct, {\"addr\": 66, \"content\": \"ABC\"})\n server.recv({\"addr\": 88, \"content\": \"abc\"})\n self.assertEqual(server.show(\"receive\"), {\"addr\": 88, \"content\": \"abc\"})"} {"task_id": "DREval/138", "entry_point": "ShoppingCart", "code": "class ShoppingCart:\n def __init__(self):\n self.items = {}\n\n def add_item(self, item, price, quantity=1):\n if item in self.items:\n self.items[item] = {'price': price, 'quantity': quantity}\n else:\n self.items[item] = {'price': price, 'quantity': quantity}\n\n def remove_item(self, item, quantity=1):\n if item in self.items:\n self.items[item]['quantity'] -= quantity\n else:\n pass\n\n def view_items(self) -> dict:\n return self.items\n\n def total_price(self) -> float:\n return sum([item['quantity'] * item['price'] for item in self.items.values()])", "inputs": ["shoppingcart = ShoppingCart()\nshoppingcart.add_item(\"apple\", 1, 5)\nassertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 5}})\n", "shoppingcart = ShoppingCart()\nshoppingcart.add_item(\"apple\", 1, 5)\nshoppingcart.remove_item(\"apple\", 3)\nassertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 2}})\n", "shoppingcart = ShoppingCart()\nshoppingcart.add_item(\"apple\", 1, 5)\nassertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 5}})\n", "shoppingcart = ShoppingCart()\nshoppingcart.add_item(\"apple\", 1, 5)\nshoppingcart.add_item(\"banana\", 2, 3)\nassertEqual(shoppingcart.total_price(), 11.0)\n", "shoppingcart = ShoppingCart()\nshoppingcart.add_item(\"apple\", 1, 5)\nassertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 5}})\nassertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 5}})\nshoppingcart.remove_item(\"apple\", 3)\nassertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 2}})\nshoppingcart.add_item(\"banana\", 2, 3)\nassertEqual(shoppingcart.total_price(), 8.0)\n"], "outputs": [], "test": "import unittest\n\n\nclass ShoppingCartTestAddItem(unittest.TestCase):\n def test_add_item_1(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 5}})\n\n def test_add_item_2(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 1}})\n\n def test_add_item_3(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"aaa\", 1)\n self.assertEqual(shoppingcart.items, {\"aaa\": {\"price\": 1, \"quantity\": 1}})\n\n def test_add_item_4(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"bbb\", 1)\n self.assertEqual(shoppingcart.items, {\"bbb\": {\"price\": 1, \"quantity\": 1}})\n\n def test_add_item_5(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"ccc\", 1)\n self.assertEqual(shoppingcart.items, {\"ccc\": {\"price\": 1, \"quantity\": 1}})\n\n def test_add_item_6(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.add_item(\"apple\", 1, 5)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 5}})\n\n\nclass ShoppingCartTestRemoveItem(unittest.TestCase):\n def test_remove_item_1(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.remove_item(\"apple\", 3)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 2}})\n\n def test_remove_item_2(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.remove_item(\"apple\")\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 4}})\n\n def test_remove_item_3(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.remove_item(\"apple\", 1)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 4}})\n\n def test_remove_item_4(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.remove_item(\"apple\", 2)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 3}})\n\n def test_remove_item_5(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.remove_item(\"apple\", 4)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 1}})\n\n def test_remove_item_6(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.remove_item(\"banana\", 4)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 5}})\n\n\nclass ShoppingCartTestViewItems(unittest.TestCase):\n def test_view_items_1(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n self.assertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 5}})\n\n def test_view_items_2(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 4)\n self.assertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 4}})\n\n def test_view_items_3(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 3)\n self.assertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 3}})\n\n def test_view_items_4(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 2)\n self.assertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 2}})\n\n def test_view_items_5(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 1)\n self.assertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 1}})\n\n\nclass ShoppingCartTestTotalPrice(unittest.TestCase):\n def test_total_price_1(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.add_item(\"banana\", 2, 3)\n self.assertEqual(shoppingcart.total_price(), 11.0)\n\n def test_total_price_2(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n shoppingcart.add_item(\"banana\", 2, 3)\n shoppingcart.remove_item(\"apple\", 3)\n self.assertEqual(shoppingcart.total_price(), 8.0)\n\n def test_total_price_3(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 1)\n shoppingcart.add_item(\"banana\", 2, 1)\n self.assertEqual(shoppingcart.total_price(), 3.0)\n\n def test_total_price_4(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 2)\n shoppingcart.add_item(\"banana\", 2, 1)\n self.assertEqual(shoppingcart.total_price(), 4.0)\n\n def test_total_price_5(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 3)\n shoppingcart.add_item(\"banana\", 2, 1)\n self.assertEqual(shoppingcart.total_price(), 5.0)\n\n\nclass ShoppingCartTest(unittest.TestCase):\n def test_shoppingcart(self):\n shoppingcart = ShoppingCart()\n shoppingcart.add_item(\"apple\", 1, 5)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 5}})\n self.assertEqual(shoppingcart.view_items(), {\"apple\": {\"price\": 1, \"quantity\": 5}})\n shoppingcart.remove_item(\"apple\", 3)\n self.assertEqual(shoppingcart.items, {\"apple\": {\"price\": 1, \"quantity\": 2}})\n shoppingcart.add_item(\"banana\", 2, 3)\n self.assertEqual(shoppingcart.total_price(), 8.0)"} {"task_id": "DREval/139", "entry_point": "SignInSystem", "code": "class SignInSystem:\n def __init__(self):\n self.users = {}\n\n def add_user(self, username):\n if username in self.users:\n return False\n else:\n self.users[username] = False\n return True\n\n def sign_in(self, username):\n if username not in self.users:\n return False\n else:\n self.users[username] = True\n return True\n\n def check_sign_in(self, username):\n if username not in self.users:\n return False\n else:\n if self.users[username]:\n return True\n else:\n return False\n\n def all_signed_in(self):\n if all(self.users.values()):\n return True\n else:\n return False\n\n def all_not_signed_in(self):\n not_signed_in_users = []\n for username, signed_in in self.users.items():\n if not signed_in:\n not_signed_in_users.append(username)\n return not_signed_in_users", "inputs": ["signin_system = SignInSystem()\nresult = signin_system.add_user(\"user1\")\nassertTrue(result)\n", "signin_system = SignInSystem()\nsignin_system.add_user(\"user1\")\nresult = signin_system.sign_in(\"user1\")\nassertTrue(result)\n", "signin_system = SignInSystem()\nsignin_system.add_user(\"user1\")\nsignin_system.sign_in(\"user1\")\nresult = signin_system.check_sign_in(\"user1\")\nassertTrue(result)\n", "signin_system = SignInSystem()\nsignin_system.add_user(\"user1\")\nsignin_system.sign_in(\"user1\")\nresult = signin_system.all_signed_in()\nassertTrue(result)\n", "signin_system = SignInSystem()\nsignin_system.add_user(\"user1\")\nsignin_system.sign_in(\"user1\")\nresult = signin_system.all_not_signed_in()\nassertEqual([], result)\n", "result = signin_system.add_user(\"user1\")\nresult = signin_system.add_user(\"user2\")\nassertTrue(result)\nresult = signin_system.sign_in(\"user1\")\nassertTrue(result)\nresult = signin_system.check_sign_in(\"user1\")\nassertTrue(result)\nresult = signin_system.all_signed_in()\nassertFalse(result)\nresult = signin_system.all_not_signed_in()\nassertEqual([\"user2\"], result)\n"], "outputs": [], "test": "import unittest\n\n\nclass SignInSystemTestAddUser(unittest.TestCase):\n def test_add_user_1(self):\n signin_system = SignInSystem()\n result = signin_system.add_user(\"user1\")\n self.assertTrue(result)\n\n def test_add_user_2(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n result = signin_system.add_user(\"user1\")\n self.assertFalse(result)\n\n def test_add_user_3(self):\n signin_system = SignInSystem()\n result = signin_system.add_user(\"aaa\")\n self.assertTrue(result)\n\n def test_add_user_4(self):\n signin_system = SignInSystem()\n result = signin_system.add_user(\"bbb\")\n self.assertTrue(result)\n\n def test_add_user_5(self):\n signin_system = SignInSystem()\n result = signin_system.add_user(\"ccc\")\n self.assertTrue(result)\n\n\nclass SignInSystemTestSignIn(unittest.TestCase):\n def test_sign_in_1(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n result = signin_system.sign_in(\"user1\")\n self.assertTrue(result)\n\n # user not exist\n def test_sign_in_2(self):\n signin_system = SignInSystem()\n result = signin_system.sign_in(\"user1\")\n self.assertFalse(result)\n\n def test_sign_in_3(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"aaa\")\n result = signin_system.sign_in(\"aaa\")\n self.assertTrue(result)\n\n def test_sign_in_4(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"bbb\")\n result = signin_system.sign_in(\"bbb\")\n self.assertTrue(result)\n\n def test_sign_in_5(self):\n signin_system = SignInSystem()\n result = signin_system.sign_in(\"ccc\")\n self.assertFalse(result)\n\n\nclass SignInSystemTestCheckSignIn(unittest.TestCase):\n # has signed in\n def test_check_sign_in_1(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n signin_system.sign_in(\"user1\")\n result = signin_system.check_sign_in(\"user1\")\n self.assertTrue(result)\n\n # hasn't signed in \n def test_check_sign_in_2(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n result = signin_system.check_sign_in(\"user1\")\n self.assertFalse(result)\n\n # not exist\n def test_check_sign_in_3(self):\n signin_system = SignInSystem()\n result = signin_system.check_sign_in(\"user1\")\n self.assertFalse(result)\n\n def test_check_sign_in_4(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"aaa\")\n signin_system.sign_in(\"aaa\")\n result = signin_system.check_sign_in(\"aaa\")\n self.assertTrue(result)\n\n def test_check_sign_in_5(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"bbb\")\n signin_system.sign_in(\"bbb\")\n result = signin_system.check_sign_in(\"bbb\")\n self.assertTrue(result)\n\n\nclass SignInSystemTestAllSignedIn(unittest.TestCase):\n def test_all_signed_in_1(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n signin_system.sign_in(\"user1\")\n result = signin_system.all_signed_in()\n self.assertTrue(result)\n\n def test_all_signed_in_2(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n result = signin_system.all_signed_in()\n self.assertFalse(result)\n\n def test_all_signed_in_3(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"aaa\")\n signin_system.sign_in(\"aaa\")\n result = signin_system.all_signed_in()\n self.assertTrue(result)\n\n def test_all_signed_in_4(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"bbb\")\n signin_system.sign_in(\"bbb\")\n result = signin_system.all_signed_in()\n self.assertTrue(result)\n\n def test_all_signed_in_5(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"aaa\")\n signin_system.add_user(\"bbb\")\n signin_system.sign_in(\"aaa\")\n result = signin_system.all_signed_in()\n self.assertFalse(result)\n\n\nclass SignInSystemTestAllNotSignedIn(unittest.TestCase):\n def test_all_not_signed_in_1(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n signin_system.sign_in(\"user1\")\n result = signin_system.all_not_signed_in()\n self.assertEqual([], result)\n\n def test_all_not_signed_in_2(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n signin_system.add_user(\"user2\")\n result = signin_system.all_not_signed_in()\n self.assertEqual([\"user1\", \"user2\"], result)\n\n def test_all_not_signed_in_3(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"aaa\")\n signin_system.sign_in(\"aaa\")\n result = signin_system.all_not_signed_in()\n self.assertEqual([], result)\n\n def test_all_not_signed_in_4(self):\n signin_system = SignInSystem()\n signin_system.add_user(\"user1\")\n signin_system.add_user(\"aaa\")\n signin_system.sign_in(\"user1\")\n result = signin_system.all_not_signed_in()\n self.assertEqual(['aaa'], result)\n\n def test_all_not_signed_in_5(self):\n signin_system = SignInSystem()\n result = signin_system.all_not_signed_in()\n self.assertEqual([], result)\n\n\nclass SignInSystemTestMain(unittest.TestCase):\n def setUp(self):\n self.signin_system = SignInSystem()\n\n def test_main(self):\n result = self.signin_system.add_user(\"user1\")\n result = self.signin_system.add_user(\"user2\")\n self.assertTrue(result)\n\n result = self.signin_system.sign_in(\"user1\")\n self.assertTrue(result)\n\n result = self.signin_system.check_sign_in(\"user1\")\n self.assertTrue(result)\n\n result = self.signin_system.all_signed_in()\n self.assertFalse(result)\n\n result = self.signin_system.all_not_signed_in()\n self.assertEqual([\"user2\"], result)"} {"task_id": "DREval/140", "entry_point": "SplitSentence", "code": "import re\n\n\nclass SplitSentence:\n\n def split_sentences(self, sentences_string):\n sentences = re.split(r'(? max_count:\n max_count = count\n\n return max_count", "inputs": ["ss = SplitSentence()\nlst = ss.split_sentences(\"aaa aaaa. bb bbbb bbb? cccc cccc. dd ddd?\")\nassertEqual(lst, ['aaa aaaa.', 'bb bbbb bbb?', 'cccc cccc.', 'dd ddd?'])\n", "ss = SplitSentence()\ncnt = ss.count_words(\"abc def\")\nassertEqual(cnt, 2)\n", "ss = SplitSentence()\ncnt = ss.process_text_file(\"aaa aaaa. bb bbbb bbb? cccc ccccccc cc ccc. dd ddd?\")\nassertEqual(cnt, 4)\n", "ss = SplitSentence()\nlst = ss.split_sentences(\"aaa aaaa. bb bbbb bbb? cccc cccc. dd ddd?\")\nassertEqual(lst, ['aaa aaaa.', 'bb bbbb bbb?', 'cccc cccc.', 'dd ddd?'])\ncnt = ss.count_words(\"abc def\")\nassertEqual(cnt, 2)\ncnt = ss.process_text_file(\"aaa aaaa. bb bbbb bbb? cccc ccccccc cc ccc. dd ddd?\")\nassertEqual(cnt, 4)\n"], "outputs": [], "test": "import unittest\n\n\nclass SplitSentenceTestSplitSentences(unittest.TestCase):\n def test_split_sentences_1(self):\n ss = SplitSentence()\n lst = ss.split_sentences(\"aaa aaaa. bb bbbb bbb? cccc cccc. dd ddd?\")\n self.assertEqual(lst, ['aaa aaaa.', 'bb bbbb bbb?', 'cccc cccc.', 'dd ddd?'])\n\n def test_split_sentences_2(self):\n ss = SplitSentence()\n lst = ss.split_sentences(\"Who is Mr. Smith? He is a teacher.\")\n self.assertEqual(lst, ['Who is Mr. Smith?', 'He is a teacher.'])\n\n def test_split_sentences_3(self):\n ss = SplitSentence()\n lst = ss.split_sentences(\"Who is A.B.C.? He is a teacher.\")\n self.assertEqual(lst, ['Who is A.B.C.?', 'He is a teacher.'])\n\n def test_split_sentences_4(self):\n ss = SplitSentence()\n lst = ss.split_sentences(\"aaa aaaa. bb bbbb bbb? cccc cccc.\")\n self.assertEqual(lst, ['aaa aaaa.', 'bb bbbb bbb?', 'cccc cccc.'])\n\n def test_split_sentences_5(self):\n ss = SplitSentence()\n lst = ss.split_sentences(\"aaa aaaa. bb bbbb bbb?\")\n self.assertEqual(lst, ['aaa aaaa.', 'bb bbbb bbb?'])\n\n\nclass SplitSentenceTestCountWords(unittest.TestCase):\n def test_count_words_1(self):\n ss = SplitSentence()\n cnt = ss.count_words(\"abc def\")\n self.assertEqual(cnt, 2)\n\n def test_count_words_2(self):\n ss = SplitSentence()\n cnt = ss.count_words(\"abc def 1\")\n self.assertEqual(cnt, 2)\n\n def test_count_words_3(self):\n ss = SplitSentence()\n cnt = ss.count_words(\"abc 1\")\n self.assertEqual(cnt, 1)\n\n def test_count_words_4(self):\n ss = SplitSentence()\n cnt = ss.count_words(\"abc def bbb1\")\n self.assertEqual(cnt, 3)\n\n def test_count_words_5(self):\n ss = SplitSentence()\n cnt = ss.count_words(\"abc def 111\")\n self.assertEqual(cnt, 2)\n\n\nclass SplitSentenceTestProcessTextFile(unittest.TestCase):\n def test_process_text_file_1(self):\n ss = SplitSentence()\n cnt = ss.process_text_file(\"aaa aaaa. bb bbbb bbb? cccc ccccccc cc ccc. dd ddd?\")\n self.assertEqual(cnt, 4)\n\n def test_process_text_file_2(self):\n ss = SplitSentence()\n cnt = ss.process_text_file(\"Mr. Smith is a teacher. Yes.\")\n self.assertEqual(cnt, 5)\n\n def test_process_text_file_3(self):\n ss = SplitSentence()\n cnt = ss.process_text_file(\"Mr. Smith is a teacher. Yes 1 2 3 4 5 6.\")\n self.assertEqual(cnt, 5)\n\n def test_process_text_file_4(self):\n ss = SplitSentence()\n cnt = ss.process_text_file(\"aaa aaaa. bb bbbb bbb? cccc ccccccc cc ccc.\")\n self.assertEqual(cnt, 4)\n\n def test_process_text_file_5(self):\n ss = SplitSentence()\n cnt = ss.process_text_file(\"aaa aaaa. bb bbbb bbb?\")\n self.assertEqual(cnt, 3)\n\n\nclass SplitSentenceTest(unittest.TestCase):\n def test_SplitSentence(self):\n ss = SplitSentence()\n lst = ss.split_sentences(\"aaa aaaa. bb bbbb bbb? cccc cccc. dd ddd?\")\n self.assertEqual(lst, ['aaa aaaa.', 'bb bbbb bbb?', 'cccc cccc.', 'dd ddd?'])\n\n cnt = ss.count_words(\"abc def\")\n self.assertEqual(cnt, 2)\n\n cnt = ss.process_text_file(\"aaa aaaa. bb bbbb bbb? cccc ccccccc cc ccc. dd ddd?\")\n self.assertEqual(cnt, 4)"} {"task_id": "DREval/141", "entry_point": "SQLGenerator", "code": "class SQLGenerator:\n def __init__(self, table_name):\n self.table_name = table_name\n\n def select(self, fields=None, condition=None):\n if fields is None:\n fields = \"*\"\n else:\n fields = \", \".join(fields)\n sql = f\"SELECT {fields} FROM {self.table_name}\"\n if condition is not None:\n sql += f\" WHERE {condition}\"\n return sql + \";\"\n\n def insert(self, data):\n fields = \", \".join(data.keys())\n values = \", \".join([f\"'{value}'\" for value in data.values()])\n sql = f\"INSERT INTO {self.table_name} ({fields}) VALUES ({values})\"\n return sql + \";\"\n\n def update(self, data, condition):\n set_clause = \", \".join([f\"{field} = '{value}'\" for field, value in data.items()])\n sql = f\"UPDATE {self.table_name} SET {set_clause} WHERE {condition}\"\n return sql + \";\"\n\n def delete(self, condition):\n sql = f\"DELETE FROM {self.table_name} WHERE {condition}\"\n return sql + \";\"\n\n def select_female_under_age(self, age):\n condition = f\"age < {age} AND gender = 'female'\"\n return self.select(condition=condition)\n\n def select_by_age_range(self, min_age, max_age):\n condition = f\"age BETWEEN {min_age} AND {max_age}\"\n return self.select(condition=condition)", "inputs": ["sql = SQLGenerator('table1')\nresult = sql.select(['field1'], \"field2 = value1\")\nassertEqual(result, \"SELECT field1 FROM table1 WHERE field2 = value1;\")\n", "sql = SQLGenerator('table1')\nresult = sql.insert({'field1': 'value1', 'field2': 'value2'})\nassertEqual(result, \"INSERT INTO table1 (field1, field2) VALUES ('value1', 'value2');\")\n", "sql = SQLGenerator('table1')\nresult = sql.update({'field1': 'new_value1', 'field2': 'new_value2'}, \"field3 = value1\")\nassertEqual(result,\n\"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2' WHERE field3 = value1;\")\n", "sql = SQLGenerator('table1')\nresult = sql.delete(\"field1 = value1\")\nassertEqual(result, \"DELETE FROM table1 WHERE field1 = value1;\")\n", "sql = SQLGenerator('table1')\nresult = sql.select_female_under_age(30)\nassertEqual(result, \"SELECT * FROM table1 WHERE age < 30 AND gender = 'female';\")\n", "sql = SQLGenerator('table1')\nresult = sql.select_by_age_range(20, 30)\nassertEqual(result, \"SELECT * FROM table1 WHERE age BETWEEN 20 AND 30;\")\n", "sql = SQLGenerator('table1')\nassertEqual(sql.select(['field1', 'field2'], \"field3 = value1\"),\n\"SELECT field1, field2 FROM table1 WHERE field3 = value1;\")\nassertEqual(sql.insert({'field1': 'value1', 'field2': 'value2'}),\n\"INSERT INTO table1 (field1, field2) VALUES ('value1', 'value2');\")\nassertEqual(sql.update({'field1': 'new_value1', 'field2': 'new_value2'},\n\"field3 = value1\"),\n\"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2' WHERE field3 = value1;\")\nassertEqual(sql.delete(\"field1 = value1\"),\n\"DELETE FROM table1 WHERE field1 = value1;\")\nassertEqual(sql.select_female_under_age(30),\n\"SELECT * FROM table1 WHERE age < 30 AND gender = 'female';\")\nassertEqual(sql.select_by_age_range(20, 30),\n\"SELECT * FROM table1 WHERE age BETWEEN 20 AND 30;\")\n"], "outputs": [], "test": "import unittest\n\nclass SQLGeneratorTestSelect(unittest.TestCase):\n def test_select_1(self):\n sql = SQLGenerator('table1')\n result = sql.select(['field1'], \"field2 = value1\")\n self.assertEqual(result, \"SELECT field1 FROM table1 WHERE field2 = value1;\")\n\n def test_select_2(self):\n sql = SQLGenerator('table1')\n result = sql.select(['field1', 'field2'], \"field3 = value1\")\n self.assertEqual(result, \"SELECT field1, field2 FROM table1 WHERE field3 = value1;\")\n\n def test_select_3(self):\n sql = SQLGenerator('table1')\n result = sql.select(['field1, field2'], \"field3 = value1\")\n self.assertEqual(result, \"SELECT field1, field2 FROM table1 WHERE field3 = value1;\")\n\n def test_select_4(self):\n sql = SQLGenerator('table1')\n result = sql.select(['field1, field2'], \"field3 = value1, field4 = value2\")\n self.assertEqual(result, \"SELECT field1, field2 FROM table1 WHERE field3 = value1, field4 = value2;\")\n\n def test_select_5(self):\n sql = SQLGenerator('table1')\n result = sql.select(['field1'], \"field2 = value1, field3 = value2\")\n self.assertEqual(result, \"SELECT field1 FROM table1 WHERE field2 = value1, field3 = value2;\")\n\n def test_select_6(self):\n sql = SQLGenerator('table1')\n result = sql.select(['field1'])\n self.assertEqual(result, \"SELECT field1 FROM table1;\")\n\n\n\nclass SQLGeneratorTestInsert(unittest.TestCase):\n def test_insert(self):\n sql = SQLGenerator('table1')\n result = sql.insert({'field1': 'value1', 'field2': 'value2'})\n self.assertEqual(result, \"INSERT INTO table1 (field1, field2) VALUES ('value1', 'value2');\")\n\n def test_insert_2(self):\n sql = SQLGenerator('table1')\n result = sql.insert({'field1': 'value1', 'field2': 'value2', 'field3': 'value3'})\n self.assertEqual(result, \"INSERT INTO table1 (field1, field2, field3) VALUES ('value1', 'value2', 'value3');\")\n\n def test_insert_3(self):\n sql = SQLGenerator('table1')\n result = sql.insert({'field1': 'value1', 'field2': 'value2', 'field3': 'value3', 'field4': 'value4'})\n self.assertEqual(result,\n \"INSERT INTO table1 (field1, field2, field3, field4) VALUES ('value1', 'value2', 'value3', 'value4');\")\n\n def test_insert_4(self):\n sql = SQLGenerator('table1')\n result = sql.insert({'field1': 'value1', 'field2': 'value2', 'field3': 'value3', 'field4': 'value4',\n 'field5': 'value5'})\n self.assertEqual(result,\n \"INSERT INTO table1 (field1, field2, field3, field4, field5) VALUES ('value1', 'value2', 'value3', 'value4', 'value5');\")\n\n def test_insert_5(self):\n sql = SQLGenerator('table1')\n result = sql.insert({'field1': 'value1', 'field2': 'value2', 'field3': 'value3', 'field4': 'value4',\n 'field5': 'value5', 'field6': 'value6'})\n self.assertEqual(result,\n \"INSERT INTO table1 (field1, field2, field3, field4, field5, field6) VALUES ('value1', 'value2', 'value3', 'value4', 'value5', 'value6');\")\n\nclass SQLGeneratorTestUpdate(unittest.TestCase):\n def test_update(self):\n sql = SQLGenerator('table1')\n result = sql.update({'field1': 'new_value1', 'field2': 'new_value2'}, \"field3 = value1\")\n self.assertEqual(result,\n \"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2' WHERE field3 = value1;\")\n\n def test_update_2(self):\n sql = SQLGenerator('table1')\n result = sql.update({'field1': 'new_value1', 'field2': 'new_value2', 'field3': 'new_value3'},\n \"field4 = value1\")\n self.assertEqual(result,\n \"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2', field3 = 'new_value3' WHERE field4 = value1;\")\n\n def test_update_3(self):\n sql = SQLGenerator('table1')\n result = sql.update({'field1': 'new_value1', 'field2': 'new_value2', 'field3': 'new_value3',\n 'field4': 'new_value4'}, \"field5 = value1\")\n self.assertEqual(result,\n \"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2', field3 = 'new_value3', field4 = 'new_value4' WHERE field5 = value1;\")\n\n def test_update_4(self):\n sql = SQLGenerator('table1')\n result = sql.update({'field1': 'new_value1', 'field2': 'new_value2', 'field3': 'new_value3',\n 'field4': 'new_value4', 'field5': 'new_value5'}, \"field6 = value1\")\n self.assertEqual(result,\n \"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2', field3 = 'new_value3', field4 = 'new_value4', field5 = 'new_value5' WHERE field6 = value1;\")\n\n def test_update_5(self):\n sql = SQLGenerator('table1')\n result = sql.update({'field1': 'new_value1', 'field2': 'new_value2', 'field3': 'new_value3',\n 'field4': 'new_value4', 'field5': 'new_value5', 'field6': 'new_value6'},\n \"field7 = value1\")\n self.assertEqual(result,\n \"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2', field3 = 'new_value3', field4 = 'new_value4', field5 = 'new_value5', field6 = 'new_value6' WHERE field7 = value1;\")\n\nclass SQLGeneratorTestDelete(unittest.TestCase):\n def test_delete(self):\n sql = SQLGenerator('table1')\n result = sql.delete(\"field1 = value1\")\n self.assertEqual(result, \"DELETE FROM table1 WHERE field1 = value1;\")\n\n def test_delete_2(self):\n sql = SQLGenerator('table1')\n result = sql.delete(\"field1 = value1 AND field2 = value2\")\n self.assertEqual(result, \"DELETE FROM table1 WHERE field1 = value1 AND field2 = value2;\")\n\n def test_delete_3(self):\n sql = SQLGenerator('table1')\n result = sql.delete(\"field1 = value1 AND field2 = value2 AND field3 = value3\")\n self.assertEqual(result, \"DELETE FROM table1 WHERE field1 = value1 AND field2 = value2 AND field3 = value3;\")\n\n def test_delete_4(self):\n sql = SQLGenerator('table1')\n result = sql.delete(\"field1 = value1 AND field2 = value2 AND field3 = value3 AND field4 = value4\")\n self.assertEqual(result,\n \"DELETE FROM table1 WHERE field1 = value1 AND field2 = value2 AND field3 = value3 AND field4 = value4;\")\n\n def test_delete_5(self):\n sql = SQLGenerator('table1')\n result = sql.delete(\"field1 = value1 AND field2 = value2 AND field3 = value3 AND field4 = value4 AND field5 = value5\")\n self.assertEqual(result,\n \"DELETE FROM table1 WHERE field1 = value1 AND field2 = value2 AND field3 = value3 AND field4 = value4 AND field5 = value5;\")\n\nclass SQLGeneratorTestSelectFemaleUnderAge(unittest.TestCase):\n def test_select_female_under_age(self):\n sql = SQLGenerator('table1')\n result = sql.select_female_under_age(30)\n self.assertEqual(result, \"SELECT * FROM table1 WHERE age < 30 AND gender = 'female';\")\n\n def test_select_female_under_age_2(self):\n sql = SQLGenerator('table1')\n result = sql.select_female_under_age(40)\n self.assertEqual(result,\"SELECT * FROM table1 WHERE age < 40 AND gender = 'female';\")\n\n def test_select_female_under_age_3(self):\n sql = SQLGenerator('table1')\n result = sql.select_female_under_age(20)\n self.assertEqual(result,\"SELECT * FROM table1 WHERE age < 20 AND gender = 'female';\")\n\n def test_select_female_under_age_4(self):\n sql = SQLGenerator('table1')\n result = sql.select_female_under_age(10)\n self.assertEqual(result,\"SELECT * FROM table1 WHERE age < 10 AND gender = 'female';\")\n\n def test_select_female_under_age_5(self):\n sql = SQLGenerator('table1')\n result = sql.select_female_under_age(50)\n self.assertEqual(result,\"SELECT * FROM table1 WHERE age < 50 AND gender = 'female';\")\n\nclass SQLGeneratorTestSelectByAgeRange(unittest.TestCase):\n def test_select_by_age_range(self):\n sql = SQLGenerator('table1')\n result = sql.select_by_age_range(20, 30)\n self.assertEqual(result, \"SELECT * FROM table1 WHERE age BETWEEN 20 AND 30;\")\n\n def test_select_by_age_range_2(self):\n sql = SQLGenerator('table1')\n result = sql.select_by_age_range(10, 20)\n self.assertEqual(result, \"SELECT * FROM table1 WHERE age BETWEEN 10 AND 20;\")\n\n def test_select_by_age_range_3(self):\n sql = SQLGenerator('table1')\n result = sql.select_by_age_range(30, 40)\n self.assertEqual(result, \"SELECT * FROM table1 WHERE age BETWEEN 30 AND 40;\")\n\n def test_select_by_age_range_4(self):\n sql = SQLGenerator('table1')\n result = sql.select_by_age_range(40, 50)\n self.assertEqual(result, \"SELECT * FROM table1 WHERE age BETWEEN 40 AND 50;\")\n\n def test_select_by_age_range_5(self):\n sql = SQLGenerator('table1')\n result = sql.select_by_age_range(50, 60)\n self.assertEqual(result, \"SELECT * FROM table1 WHERE age BETWEEN 50 AND 60;\")\n\n\nclass SQLGeneratorTestMain(unittest.TestCase):\n def test_main(self):\n sql = SQLGenerator('table1')\n self.assertEqual(sql.select(['field1', 'field2'], \"field3 = value1\"),\n \"SELECT field1, field2 FROM table1 WHERE field3 = value1;\")\n self.assertEqual(sql.insert({'field1': 'value1', 'field2': 'value2'}),\n \"INSERT INTO table1 (field1, field2) VALUES ('value1', 'value2');\")\n self.assertEqual(sql.update({'field1': 'new_value1', 'field2': 'new_value2'},\n \"field3 = value1\"),\n \"UPDATE table1 SET field1 = 'new_value1', field2 = 'new_value2' WHERE field3 = value1;\")\n self.assertEqual(sql.delete(\"field1 = value1\"),\n \"DELETE FROM table1 WHERE field1 = value1;\")\n self.assertEqual(sql.select_female_under_age(30),\n \"SELECT * FROM table1 WHERE age < 30 AND gender = 'female';\")\n self.assertEqual(sql.select_by_age_range(20, 30),\n \"SELECT * FROM table1 WHERE age BETWEEN 20 AND 30;\")"} {"task_id": "DREval/142", "entry_point": "SQLQueryBuilder", "code": "class SQLQueryBuilder:\n\n @staticmethod\n def select(table, columns='*', where=None):\n if columns != '*':\n columns = ', '.join(columns)\n query = f\"SELECT {columns} FROM {table}\"\n if where:\n query += \" WHERE \" + ' AND '.join(f\"{k}='{v}'\" for k, v in where.items())\n return query\n\n @staticmethod\n def insert(table, data):\n keys = ', '.join(data.keys())\n values = ', '.join(f\"'{v}'\" for v in data.values())\n return f\"INSERT INTO {table} ({keys}) VALUES ({values})\"\n\n @staticmethod\n def delete(table, where=None):\n query = f\"DELETE FROM {table}\"\n if where:\n query += \" WHERE \" + ' AND '.join(f\"{k}='{v}'\" for k, v in where.items())\n return query\n\n @staticmethod\n def update(table, data, where=None):\n update_str = ', '.join(f\"{k}='{v}'\" for k, v in data.items())\n query = f\"UPDATE {table} SET {update_str}\"\n if where:\n query += \" WHERE \" + ' AND '.join(f\"{k}='{v}'\" for k, v in where.items())\n return query", "inputs": ["assertEqual(\nSQLQueryBuilder.select('users', [\"id\", \"name\"], {'age': 30}),\n\"SELECT id, name FROM users WHERE age='30'\"\n)\n", "assertEqual(\nSQLQueryBuilder.insert('users', {'name': 'Tom', 'age': 30}),\n\"INSERT INTO users (name, age) VALUES ('Tom', '30')\"\n)\n", "assertEqual(\nSQLQueryBuilder.delete('users', {'name': 'Tom'}),\n\"DELETE FROM users WHERE name='Tom'\"\n)\n", "assertEqual(\nSQLQueryBuilder.update('users', {'age': 35}, {'name': 'Tom'}),\n\"UPDATE users SET age='35' WHERE name='Tom'\"\n)\n", "assertEqual(\nSQLQueryBuilder.select('users', [\"id\", \"name\"], {'age': 30}),\n\"SELECT id, name FROM users WHERE age='30'\"\n)\nassertEqual(\nSQLQueryBuilder.insert('users', {'name': 'Tom', 'age': 30}),\n\"INSERT INTO users (name, age) VALUES ('Tom', '30')\"\n)\nassertEqual(\nSQLQueryBuilder.delete('users', {'name': 'Tom'}),\n\"DELETE FROM users WHERE name='Tom'\"\n)\nassertEqual(\nSQLQueryBuilder.update('users', {'age': 35}, {'name': 'Tom'}),\n\"UPDATE users SET age='35' WHERE name='Tom'\"\n)\n"], "outputs": [], "test": "import unittest\n\n\nclass SQLQueryBuilderTestSelect(unittest.TestCase):\n def test_select_1(self):\n self.assertEqual(\n SQLQueryBuilder.select('users', [\"id\", \"name\"], {'age': 30}),\n \"SELECT id, name FROM users WHERE age='30'\"\n )\n\n def test_select_2(self):\n self.assertEqual(\n SQLQueryBuilder.select('students', [\"id\", \"name\"], {'age': 18}),\n \"SELECT id, name FROM students WHERE age='18'\"\n )\n\n def test_select_3(self):\n self.assertEqual(\n SQLQueryBuilder.select('items', [\"id\", \"name\"], {'price': 1.0}),\n \"SELECT id, name FROM items WHERE price='1.0'\"\n )\n\n def test_select_4(self):\n self.assertEqual(\n SQLQueryBuilder.select('users', [\"id\"], {'age': 30}),\n \"SELECT id FROM users WHERE age='30'\"\n )\n\n def test_select_5(self):\n self.assertEqual(\n SQLQueryBuilder.select('users', [\"name\"], {'age': 30}),\n \"SELECT name FROM users WHERE age='30'\"\n )\n\n def test_select_6(self):\n self.assertEqual(\n SQLQueryBuilder.select('users', [\"name\"]),\n \"SELECT name FROM users\"\n )\n\n def test_select_7(self):\n self.assertEqual(\n SQLQueryBuilder.select('users', \"*\"),\n \"SELECT * FROM users\"\n )\n\n\nclass SQLQueryBuilderTestInsert(unittest.TestCase):\n def test_insert_1(self):\n self.assertEqual(\n SQLQueryBuilder.insert('users', {'name': 'Tom', 'age': 30}),\n \"INSERT INTO users (name, age) VALUES ('Tom', '30')\"\n )\n\n def test_insert_2(self):\n self.assertEqual(\n SQLQueryBuilder.insert('students', {'name': 'Tom', 'age': 18}),\n \"INSERT INTO students (name, age) VALUES ('Tom', '18')\"\n )\n\n def test_insert_3(self):\n self.assertEqual(\n SQLQueryBuilder.insert('items', {'name': 'apple', 'price': 1.0}),\n \"INSERT INTO items (name, price) VALUES ('apple', '1.0')\"\n )\n\n def test_insert_4(self):\n self.assertEqual(\n SQLQueryBuilder.insert('users', {'name': 'Tom'}),\n \"INSERT INTO users (name) VALUES ('Tom')\"\n )\n\n def test_insert_5(self):\n self.assertEqual(\n SQLQueryBuilder.insert('users', {'name': 'Tom', 'age': 30, 'region': 'USA'}),\n \"INSERT INTO users (name, age, region) VALUES ('Tom', '30', 'USA')\"\n )\n\n\nclass SQLQueryBuilderTestDetele(unittest.TestCase):\n def test_delete_1(self):\n self.assertEqual(\n SQLQueryBuilder.delete('users', {'name': 'Tom'}),\n \"DELETE FROM users WHERE name='Tom'\"\n )\n\n def test_delete_2(self):\n self.assertEqual(\n SQLQueryBuilder.delete('students', {'name': 'Tom'}),\n \"DELETE FROM students WHERE name='Tom'\"\n )\n\n def test_delete_3(self):\n self.assertEqual(\n SQLQueryBuilder.delete('items', {'name': 'apple'}),\n \"DELETE FROM items WHERE name='apple'\"\n )\n\n def test_delete_4(self):\n self.assertEqual(\n SQLQueryBuilder.delete('items', {'name': 'aaa'}),\n \"DELETE FROM items WHERE name='aaa'\"\n )\n\n def test_delete_5(self):\n self.assertEqual(\n SQLQueryBuilder.delete('items', {'name': 'bbb'}),\n \"DELETE FROM items WHERE name='bbb'\"\n )\n\n def test_delete_6(self):\n self.assertEqual(\n SQLQueryBuilder.delete('items'),\n \"DELETE FROM items\"\n )\n\n\nclass SQLQueryBuilderTestUpdate(unittest.TestCase):\n def test_update_1(self):\n self.assertEqual(\n SQLQueryBuilder.update('users', {'age': 35}, {'name': 'Tom'}),\n \"UPDATE users SET age='35' WHERE name='Tom'\"\n )\n\n def test_update_2(self):\n self.assertEqual(\n SQLQueryBuilder.update('students', {'age': 18}, {'name': 'Tom'}),\n \"UPDATE students SET age='18' WHERE name='Tom'\"\n )\n\n def test_update_3(self):\n self.assertEqual(\n SQLQueryBuilder.update('items', {'price': 1.0}, {'name': 'apple'}),\n \"UPDATE items SET price='1.0' WHERE name='apple'\"\n )\n\n def test_update_4(self):\n self.assertEqual(\n SQLQueryBuilder.update('items', {'price': 1.0}, {'name': 'aaa'}),\n \"UPDATE items SET price='1.0' WHERE name='aaa'\"\n )\n\n def test_update_5(self):\n self.assertEqual(\n SQLQueryBuilder.update('items', {'price': 1.0}, {'name': 'bbb'}),\n \"UPDATE items SET price='1.0' WHERE name='bbb'\"\n )\n\n def test_update_6(self):\n self.assertEqual(\n SQLQueryBuilder.update('items', {'price': 1.0}),\n \"UPDATE items SET price='1.0'\"\n )\n\n\nclass SQLQueryBuilderTestMain(unittest.TestCase):\n def test_main(self):\n self.assertEqual(\n SQLQueryBuilder.select('users', [\"id\", \"name\"], {'age': 30}),\n \"SELECT id, name FROM users WHERE age='30'\"\n )\n self.assertEqual(\n SQLQueryBuilder.insert('users', {'name': 'Tom', 'age': 30}),\n \"INSERT INTO users (name, age) VALUES ('Tom', '30')\"\n )\n self.assertEqual(\n SQLQueryBuilder.delete('users', {'name': 'Tom'}),\n \"DELETE FROM users WHERE name='Tom'\"\n )\n self.assertEqual(\n SQLQueryBuilder.update('users', {'age': 35}, {'name': 'Tom'}),\n \"UPDATE users SET age='35' WHERE name='Tom'\"\n )"} {"task_id": "DREval/143", "entry_point": "Statistics3", "code": "import math\nclass Statistics3:\n @staticmethod\n def median(data):\n sorted_data = sorted(data)\n n = len(sorted_data)\n if n % 2 == 1:\n return sorted_data[n // 2]\n else:\n return (sorted_data[n // 2 - 1] + sorted_data[n // 2]) / 2\n\n @staticmethod\n def mode(data):\n counts = {}\n for value in data:\n counts[value] = counts.get(value, 0) + 1\n max_count = max(counts.values())\n mode_values = [value for value, count in counts.items() if count == max_count]\n return mode_values\n\n @staticmethod\n def correlation(x, y):\n n = len(x)\n mean_x = sum(x) / n\n mean_y = sum(y) / n\n numerator = sum((xi - mean_x) * (yi - mean_y) for xi, yi in zip(x, y))\n denominator = math.sqrt(sum((xi - mean_x) ** 2 for xi in x) * sum((yi - mean_y) ** 2 for yi in y))\n if denominator == 0:\n return None\n return numerator / denominator\n\n @staticmethod\n def mean(data):\n if len(data) == 0:\n return None\n return sum(data) / len(data)\n\n @staticmethod\n def correlation_matrix(data):\n matrix = []\n for i in range(len(data[0])):\n row = []\n for j in range(len(data[0])):\n column1 = [row[i] for row in data]\n column2 = [row[j] for row in data]\n correlation = Statistics3.correlation(column1, column2)\n row.append(correlation)\n matrix.append(row)\n return matrix\n\n @staticmethod\n def standard_deviation(data):\n n = len(data)\n if n < 2:\n return None\n mean_value = Statistics3.mean(data)\n variance = sum((x - mean_value) ** 2 for x in data) / (n - 1)\n return math.sqrt(variance)\n\n @staticmethod\n def z_score(data):\n mean = Statistics3.mean(data)\n std_deviation = Statistics3.standard_deviation(data)\n if std_deviation is None or std_deviation == 0:\n return None\n return [(x - mean) / std_deviation for x in data]", "inputs": ["statistics3 = Statistics3()\nassertEqual(statistics3.median([1, 2, 3, 4]), 2.5)\n", "statistics3 = Statistics3()\nassertEqual(statistics3.mode([1, 2, 3, 3]), [3])\n", "statistics3 = Statistics3()\nassertEqual(statistics3.correlation([1, 2, 3], [4, 5, 6]), 1.0)\n", "statistics3 = Statistics3()\nassertEqual(statistics3.mean([1, 2, 3]), 2.0)\n", "statistics3 = Statistics3()\nassertEqual(statistics3.correlation_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])\n", "statistics3 = Statistics3()\nassertEqual(statistics3.standard_deviation([1, 2, 3]), 1.0)\n", "statistics3 = Statistics3()\nassertEqual(statistics3.z_score([1, 2, 3, 4]), [-1.161895003862225, -0.3872983346207417, 0.3872983346207417, 1.161895003862225])\n", "statistics3 = Statistics3()\nassertEqual(statistics3.median([1, 2, 3, 4]), 2.5)\nassertEqual(statistics3.mode([1, 2, 3, 3]), [3])\nassertEqual(statistics3.correlation([1, 2, 3], [4, 5, 6]), 1.0)\nassertEqual(statistics3.mean([1, 2, 3]), 2.0)\nassertEqual(statistics3.correlation_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])\nassertEqual(statistics3.standard_deviation([1, 2, 3]), 1.0)\nassertEqual(statistics3.z_score([1, 2, 3, 4]), [-1.161895003862225, -0.3872983346207417, 0.3872983346207417, 1.161895003862225])\n"], "outputs": [], "test": "import unittest\n\nclass Statistics3TestMedian(unittest.TestCase):\n def test_median(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.median([1, 2, 3, 4]), 2.5)\n\n def test_median_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.median([1, 2, 3, 4, 5]), 3)\n\n def test_median_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.median([1, 2, 3, 4, 5, 6]), 3.5)\n\n def test_median_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.median([1, 2, 3, 4, 5, 6, 7]), 4)\n\n def test_median_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.median([1, 2, 3, 4, 5, 6, 7, 8]), 4.5)\n\nclass Statistics3TestMode(unittest.TestCase):\n def test_mode(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mode([1, 2, 3, 3]), [3])\n\n def test_mode_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mode([1, 2, 3, 3, 4, 4]), [3, 4])\n\n def test_mode_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mode([1, 2, 3, 3, 4, 4, 5]), [3, 4])\n\n def test_mode_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mode([1, 2, 3, 3, 4, 4, 5, 5]), [3, 4, 5])\n\n def test_mode_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mode([1, 2, 3, 3, 4, 4, 5, 5, 6]), [3, 4, 5])\n\nclass Statistics3TestCorrelation(unittest.TestCase):\n def test_correlation(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation([1, 2, 3], [4, 5, 6]), 1.0)\n\n def test_correlation_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation([1, 2, 3, 4], [5, 6, 7, 8]), 1.0)\n\n def test_correlation_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation([1, 2, 3], [1,2,3]), 1.0)\n\n def test_correlation_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation([1, 1,1], [2,2,2]), None)\n\n def test_correlation_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation([1, 1,1], [1,1,1]), None)\n\nclass Statistics3TestMean(unittest.TestCase):\n def test_mean(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mean([1, 2, 3]), 2.0)\n\n def test_mean_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mean([]), None)\n\n def test_mean_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mean([1, 1, 1]), 1.0)\n\n def test_mean_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mean([1, 1, 1, 1]), 1.0)\n\n def test_mean_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.mean([1, 1, 1, 1, 1]), 1.0)\n\nclass Statistics3TestCorrelationMatrix(unittest.TestCase):\n def test_correlation_matrix(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])\n\n def test_correlation_matrix_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation_matrix([[1, 2, 3], [4, 5, 6]]), [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])\n\n def test_correlation_matrix_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation_matrix([[1, 2, 3]]), [[None, None, None], [None, None, None], [None, None, None]])\n\n def test_correlation_matrix_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11,12]]), [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])\n\n def test_correlation_matrix_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.correlation_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11,12], [13, 14, 15]]), [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])\n\nclass Statistics3TestStandardDeviation(unittest.TestCase):\n def test_standard_deviation(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.standard_deviation([1, 2, 3]), 1.0)\n\n def test_standard_deviation_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.standard_deviation([1, 1, 1]), 0.0)\n\n def test_standard_deviation_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.standard_deviation([1, 1]), 0.0)\n\n def test_standard_deviation_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.standard_deviation([1, 1, 1, 1]), 0.0)\n\n def test_standard_deviation_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.standard_deviation([1, 1, 2, 1, 4]), 1.3038404810405297)\n\n\nclass Statistics3TestZScore(unittest.TestCase):\n def test_z_score(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.z_score([1, 2, 3, 4]), [-1.161895003862225, -0.3872983346207417, 0.3872983346207417, 1.161895003862225])\n\n def test_z_score_2(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.z_score([1, 1, 1, 1]), None)\n\n def test_z_score_3(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.z_score([1]),None)\n\n def test_z_score_4(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.z_score([1, 1, 2, 3]), [-0.7833494518006403,-0.7833494518006403,0.26111648393354675,1.3055824196677337])\n\n def test_z_score_5(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.z_score([1, 1, 1, 1, 1]), None)\n\n\nclass Statistics3TestMain(unittest.TestCase):\n def test_main(self):\n statistics3 = Statistics3()\n self.assertEqual(statistics3.median([1, 2, 3, 4]), 2.5)\n self.assertEqual(statistics3.mode([1, 2, 3, 3]), [3])\n self.assertEqual(statistics3.correlation([1, 2, 3], [4, 5, 6]), 1.0)\n self.assertEqual(statistics3.mean([1, 2, 3]), 2.0)\n self.assertEqual(statistics3.correlation_matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])\n self.assertEqual(statistics3.standard_deviation([1, 2, 3]), 1.0)\n self.assertEqual(statistics3.z_score([1, 2, 3, 4]), [-1.161895003862225, -0.3872983346207417, 0.3872983346207417, 1.161895003862225])"} {"task_id": "DREval/144", "entry_point": "StockPortfolioTracker", "code": "class StockPortfolioTracker:\n def __init__(self, cash_balance):\n self.portfolio = []\n self.cash_balance = cash_balance\n\n def add_stock(self, stock):\n for pf in self.portfolio:\n if pf['name'] == stock['name']:\n pf['quantity'] += stock['quantity']\n return\n\n self.portfolio.append(stock)\n\n def remove_stock(self, stock):\n for pf in self.portfolio:\n if pf['name'] == stock['name'] and pf['quantity'] >= stock['quantity']:\n pf['quantity'] -= stock['quantity']\n if pf['quantity'] == 0:\n self.portfolio.remove(pf)\n return True\n return False\n\n def buy_stock(self, stock):\n if stock['price'] * stock['quantity'] > self.cash_balance:\n return False\n else:\n self.add_stock(stock)\n self.cash_balance -= stock['price'] * stock['quantity']\n return True\n\n def sell_stock(self, stock):\n if self.remove_stock(stock) == False:\n return False\n self.cash_balance += stock['price'] * stock['quantity']\n return True\n\n def calculate_portfolio_value(self):\n total_value = self.cash_balance\n for stock in self.portfolio:\n total_value += stock['price'] * stock['quantity']\n return total_value\n\n def get_portfolio_summary(self):\n summary = []\n for stock in self.portfolio:\n value = self.get_stock_value(stock)\n summary.append({\"name\": stock[\"name\"], \"value\": value})\n portfolio_value = self.calculate_portfolio_value()\n return portfolio_value, summary\n\n def get_stock_value(self, stock):\n return stock['price'] * stock['quantity']", "inputs": ["tracker = StockPortfolioTracker(10000.0)\ntracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\nassertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}])\n", "tracker = StockPortfolioTracker(10000.0)\ntracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\nassertEqual(tracker.remove_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\nassertEqual(tracker.portfolio, [])\n", "tracker = StockPortfolioTracker(10000.0)\nassertEqual(tracker.buy_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\nassertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}])\nassertEqual(tracker.cash_balance, 8500.0)\n", "tracker = StockPortfolioTracker(10000.0)\ntracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\nassertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 9}), True)\nassertEqual(tracker.portfolio, [{\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 1}])\nassertEqual(tracker.cash_balance, 11350.0)\n", "tracker = StockPortfolioTracker(10000.0)\ntracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\nassertEqual(tracker.calculate_portfolio_value(), 11500.0)\n", "tracker = StockPortfolioTracker(10000.0)\ntracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\nassertEqual(tracker.get_portfolio_summary(), (11500.0, [{'name': 'AAPL', 'value': 1500.0}]))\n", "tracker = StockPortfolioTracker(10000.0)\nassertEqual(tracker.get_stock_value({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), 1500.0)\n", "tracker = StockPortfolioTracker(10000.0)\nassertEqual(tracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), None)\nassertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}])\nassertEqual(tracker.buy_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), True)\nassertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n{'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\nassertEqual(tracker.cash_balance, 8500.0)\nassertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 9}), True)\nassertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 1},\n{'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\nassertEqual(tracker.cash_balance, 9850.0)\nassertEqual(tracker.remove_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 1}), True)\nassertEqual(tracker.portfolio, [{'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\nassertEqual(tracker.calculate_portfolio_value(), 11350.0)\nassertEqual(tracker.get_portfolio_summary(), (11350.0, [{'name': 'MSFT', 'value': 1500.0}]))\nassertEqual(tracker.get_stock_value({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), 1500.0)\n"], "outputs": [], "test": "import unittest\n\n\nclass StockPortfolioTrackerTestAddStock(unittest.TestCase):\n def test_add_stock(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}])\n\n def test_add_stock_2(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n tracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 20}])\n\n def test_add_stock_3(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n tracker.add_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10})\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n\n def test_add_stock_4(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n tracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n tracker.add_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10})\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 20},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n\n def test_add_stock_5(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n tracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10})\n tracker.add_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10})\n tracker.add_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10})\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 20},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 20}])\n\n\nclass StockPortfolioTrackerTestRemoveStock(unittest.TestCase):\n def test_remove_stock(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.remove_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [])\n\n def test_remove_stock_2(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.remove_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n\n def test_remove_stock_3(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.remove_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 20}), False)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n\n def test_remove_stock_4(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.remove_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), False)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}])\n\n def test_remove_stock_5(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.remove_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}])\n\n\nclass StockPortfolioTrackerTestBuyStock(unittest.TestCase):\n def test_buy_stock(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.buy_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.cash_balance, 8500.0)\n\n def test_buy_stock_2(self):\n tracker = StockPortfolioTracker(1000.0)\n self.assertEqual(tracker.buy_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), False)\n self.assertEqual(tracker.portfolio, [])\n self.assertEqual(tracker.cash_balance, 1000.0)\n\n def test_buy_stock_3(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.buy_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 20}])\n self.assertEqual(tracker.cash_balance, 8500.0)\n\n def test_buy_stock_4(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.buy_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.buy_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 20}])\n self.assertEqual(tracker.cash_balance, 7000.0)\n\n def test_buy_stock_5(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.buy_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.buy_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 20},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.cash_balance, 7000.0)\n\n\nclass StockPortfolioTrackerTestSellStock(unittest.TestCase):\n def test_sell_stock(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 9}), True)\n self.assertEqual(tracker.portfolio, [{\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 1}])\n self.assertEqual(tracker.cash_balance, 11350.0)\n\n def test_sell_stock_2(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 20}), False)\n self.assertEqual(tracker.portfolio, [{\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}])\n self.assertEqual(tracker.cash_balance, 10000.0)\n\n def test_sell_stock_3(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), False)\n self.assertEqual(tracker.portfolio, [])\n self.assertEqual(tracker.cash_balance, 10000.0)\n\n def test_sell_stock_4(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 20}]\n self.assertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 20}), True)\n self.assertEqual(tracker.portfolio, [])\n self.assertEqual(tracker.cash_balance, 13000.0)\n\n def test_sell_stock_5(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 20},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 20}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.cash_balance, 13000.0)\n\n\nclass StockPortfolioTrackerTestCalculatePortfolioValue(unittest.TestCase):\n def test_calculate_portfolio_value(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.calculate_portfolio_value(), 11500.0)\n\n def test_calculate_portfolio_value_2(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.calculate_portfolio_value(), 13000.0)\n\n def test_calculate_portfolio_value_3(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.calculate_portfolio_value(), 10000.0)\n\n def test_calculate_portfolio_value_4(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 0}]\n self.assertEqual(tracker.calculate_portfolio_value(), 10000.0)\n\n def test_calculate_portfolio_value_5(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 0.0, 'quantity': 10}]\n self.assertEqual(tracker.calculate_portfolio_value(), 10000.0)\n\n\nclass StockPortfolioTrackerTestGetPortfolioSummary(unittest.TestCase):\n def test_get_portfolio_summary(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.get_portfolio_summary(), (11500.0, [{'name': 'AAPL', 'value': 1500.0}]))\n\n def test_get_portfolio_summary_2(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.get_portfolio_summary(),\n (13000.0, [{'name': 'AAPL', 'value': 1500.0}, {'name': 'MSFT', 'value': 1500.0}]))\n\n def test_get_portfolio_summary_3(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.get_portfolio_summary(), (10000.0, []))\n\n def test_get_portfolio_summary_4(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 0}]\n self.assertEqual(tracker.get_portfolio_summary(), (10000.0, [{'name': 'AAPL', 'value': 0.0}]))\n\n def test_get_portfolio_summary_5(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 0.0, 'quantity': 10}]\n self.assertEqual(tracker.get_portfolio_summary(), (10000.0, [{'name': 'AAPL', 'value': 0.0}]))\n\n\nclass StockPortfolioTrackerTestGetStockValue(unittest.TestCase):\n def test_get_stock_value(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.get_stock_value({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), 1500.0)\n\n def test_get_stock_value_2(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.get_stock_value({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 0}), 0.0)\n\n def test_get_stock_value_3(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.get_stock_value({\"name\": \"AAPL\", \"price\": 0.0, \"quantity\": 10}), 0.0)\n\n def test_get_stock_value_4(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.get_stock_value({\"name\": \"AAPL\", \"price\": 0.0, \"quantity\": 0}), 0.0)\n\n def test_get_stock_value_5(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.get_stock_value({\"name\": \"MSFL\", \"price\": 150.0, \"quantity\": 2}), 300.0)\n\n\nclass StockPortfolioTrackerTestMain(unittest.TestCase):\n def test_main(self):\n tracker = StockPortfolioTracker(10000.0)\n self.assertEqual(tracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), None)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.buy_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.cash_balance, 8500.0)\n self.assertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 9}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 1},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.cash_balance, 9850.0)\n self.assertEqual(tracker.remove_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 1}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.calculate_portfolio_value(), 11350.0)\n self.assertEqual(tracker.get_portfolio_summary(), (11350.0, [{'name': 'MSFT', 'value': 1500.0}]))\n self.assertEqual(tracker.get_stock_value({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), 1500.0)\n\n def test_main_2(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.add_stock({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), None)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.remove_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.calculate_portfolio_value(), 11500.0)\n self.assertEqual(tracker.get_portfolio_summary(), (11500.0, [{'name': 'MSFT', 'value': 1500.0}]))\n self.assertEqual(tracker.get_stock_value({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), 1500.0)\n self.assertEqual(tracker.buy_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'MSFT', 'price': 150.0, 'quantity': 10},\n {'name': 'AAPL', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.cash_balance, 8500.0)\n\n def test_main_3(self):\n tracker = StockPortfolioTracker(10000.0)\n tracker.portfolio = [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}]\n self.assertEqual(tracker.get_stock_value({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), 1500.0)\n self.assertEqual(tracker.buy_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 20},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.cash_balance, 8500.0)\n self.assertEqual(tracker.sell_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'AAPL', 'price': 150.0, 'quantity': 10},\n {'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.cash_balance, 10000.0)\n self.assertEqual(tracker.remove_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), True)\n self.assertEqual(tracker.portfolio, [{'name': 'MSFT', 'price': 150.0, 'quantity': 10}])\n self.assertEqual(tracker.calculate_portfolio_value(), 11500.0)\n self.assertEqual(tracker.get_portfolio_summary(), (11500.0, [{'name': 'MSFT', 'value': 1500.0}]))\n self.assertEqual(tracker.get_stock_value({\"name\": \"MSFT\", \"price\": 150.0, \"quantity\": 10}), 1500.0)\n self.assertEqual(tracker.add_stock({\"name\": \"AAPL\", \"price\": 150.0, \"quantity\": 10}), None)\n self.assertEqual(tracker.portfolio, [{'name': 'MSFT', 'price': 150.0, 'quantity': 10},\n {'name': 'AAPL', 'price': 150.0, 'quantity': 10}])"} {"task_id": "DREval/145", "entry_point": "Thermostat", "code": "import time\n\nclass Thermostat:\n def __init__(self, current_temperature, target_temperature, mode):\n self.current_temperature = current_temperature\n self.target_temperature = target_temperature\n self.mode = mode\n\n def get_target_temperature(self):\n return self.target_temperature\n\n def set_target_temperature(self, temperature):\n self.target_temperature = temperature\n\n def get_mode(self):\n return self.mode\n\n def set_mode(self, mode):\n if mode in ['heat', 'cool']:\n self.mode = mode\n else:\n return False\n\n def auto_set_mode(self):\n if self.current_temperature < self.target_temperature:\n self.mode = 'heat'\n else:\n self.mode = 'cool'\n\n def auto_check_conflict(self):\n if self.current_temperature > self.target_temperature:\n if self.mode == 'cool':\n return True\n else:\n self.auto_set_mode()\n return False\n else:\n if self.mode == 'heat':\n return True\n else:\n self.auto_set_mode()\n return False\n\n def simulate_operation(self):\n self.auto_set_mode()\n use_time = 0\n if self.mode == 'heat':\n while(self.current_temperature < self.target_temperature):\n self.current_temperature += 1\n use_time += 1\n else:\n while(self.current_temperature > self.target_temperature):\n self.current_temperature -= 1\n use_time += 1\n return use_time", "inputs": ["t = Thermostat(20, 25, 'heat')\nassertEqual(t.get_target_temperature(), 25)\n", "t = Thermostat(20, 25, 'heat')\nt.set_target_temperature(30)\nassertEqual(t.get_target_temperature(), 30)\n", "t = Thermostat(20, 25, 'heat')\nassertEqual(t.get_mode(), 'heat')\n", "t = Thermostat(20, 25, 'heat')\nt.set_mode('cool')\nassertEqual(t.get_mode(), 'cool')\n", "t = Thermostat(20, 25, 'heat')\nt.auto_set_mode()\nassertEqual(t.get_mode(), 'heat')\n", "t = Thermostat(30, 25, 'cool')\nassertTrue(t.auto_check_conflict())\n", "t = Thermostat(20, 25, 'heat')\nassertEqual(t.simulate_operation(), 5)\nassertEqual(t.get_mode(), 'heat')\nassertEqual(t.current_temperature, 25)\n", "t = Thermostat(20, 37.5, 'cool')\nassertEqual(t.get_target_temperature(), 37.5)\nt.set_target_temperature(37.6)\nassertEqual(t.target_temperature, 37.6)\nassertEqual(t.get_mode(), 'cool')\nassertFalse(t.set_mode('test'))\nassertFalse(t.auto_check_conflict())\nassertEqual(t.get_mode(), 'heat')\nassertEqual(t.simulate_operation(), 18)\n"], "outputs": [], "test": "import unittest\n\nclass ThermostatTestGetTargetTemperature(unittest.TestCase):\n def test_get_target_temperature_1(self):\n t = Thermostat(20, 25, 'heat')\n self.assertEqual(t.get_target_temperature(), 25)\n\n def test_get_target_temperature_2(self):\n t = Thermostat(20, 25, 'cool')\n self.assertEqual(t.get_target_temperature(), 25)\n\n def test_get_target_temperature_3(self):\n t = Thermostat(20, 25, 'test')\n self.assertEqual(t.get_target_temperature(), 25)\n\n def test_get_target_temperature_4(self):\n t = Thermostat(25, 25, 'cool')\n self.assertEqual(t.get_target_temperature(), 25)\n\n def test_get_target_temperature_5(self):\n t = Thermostat(25, 25, 'heat')\n self.assertEqual(t.get_target_temperature(), 25)\n\n\nclass ThermostatTestSetTargetTemperature(unittest.TestCase):\n def test_set_target_temperature_1(self):\n t = Thermostat(20, 25, 'heat')\n t.set_target_temperature(30)\n self.assertEqual(t.get_target_temperature(), 30)\n\n def test_set_target_temperature_2(self):\n t = Thermostat(20, 25, 'cool')\n t.set_target_temperature(10)\n self.assertEqual(t.get_target_temperature(), 10)\n\n def test_set_target_temperature_3(self):\n t = Thermostat(20, 25, 'test')\n t.set_target_temperature(10)\n self.assertEqual(t.get_target_temperature(), 10)\n\n def test_set_target_temperature_4(self):\n t = Thermostat(25, 25, 'cool')\n t.set_target_temperature(10)\n self.assertEqual(t.get_target_temperature(), 10)\n\n def test_set_target_temperature_5(self):\n t = Thermostat(25, 25, 'heat')\n t.set_target_temperature(10)\n self.assertEqual(t.get_target_temperature(), 10)\n\n\nclass ThermostatTestGetMode(unittest.TestCase):\n def test_get_mode_1(self):\n t = Thermostat(20, 25, 'heat')\n self.assertEqual(t.get_mode(), 'heat')\n\n def test_get_mode_2(self):\n t = Thermostat(20, 25, 'cool')\n self.assertEqual(t.get_mode(), 'cool')\n\n def test_get_mode_3(self):\n t = Thermostat(20, 25, 'test')\n self.assertEqual(t.get_mode(), 'test')\n\n def test_get_mode_4(self):\n t = Thermostat(25, 25, 'cool')\n self.assertEqual(t.get_mode(), 'cool')\n\n def test_get_mode_5(self):\n t = Thermostat(25, 25, 'heat')\n self.assertEqual(t.get_mode(), 'heat')\n\n\nclass ThermostatTestSetMode(unittest.TestCase):\n def test_set_mode_1(self):\n t = Thermostat(20, 25, 'heat')\n t.set_mode('cool')\n self.assertEqual(t.get_mode(), 'cool')\n\n # use mode that not in ['heat', 'cool']\n def test_set_mode_2(self):\n t = Thermostat(20, 25, 'heat')\n self.assertFalse(t.set_mode('test'))\n\n def test_set_mode_3(self):\n t = Thermostat(20, 25, 'cool')\n t.set_mode('heat')\n self.assertEqual(t.get_mode(), 'heat')\n\n def test_set_mode_4(self):\n t = Thermostat(20, 25, 'test')\n t.set_mode('heat')\n self.assertEqual(t.get_mode(), 'heat')\n\n def test_set_mode_5(self):\n t = Thermostat(25, 25, 'cool')\n t.set_mode('heat')\n self.assertEqual(t.get_mode(), 'heat')\n\n\nclass ThermostatTestAutoSetMode(unittest.TestCase):\n def test_auto_set_mode_1(self):\n t = Thermostat(20, 25, 'heat')\n t.auto_set_mode()\n self.assertEqual(t.get_mode(), 'heat')\n\n def test_auto_set_mode_2(self):\n t = Thermostat(25, 20, 'heat')\n t.auto_set_mode()\n self.assertEqual(t.get_mode(), 'cool')\n\n def test_auto_set_mode_3(self):\n t = Thermostat(25, 20, 'cool')\n t.auto_set_mode()\n self.assertEqual(t.get_mode(), 'cool')\n\n def test_auto_set_mode_4(self):\n t = Thermostat(20, 25, 'cool')\n t.auto_set_mode()\n self.assertEqual(t.get_mode(), 'heat')\n\n def test_auto_set_mode_5(self):\n t = Thermostat(25, 25, 'cool')\n t.auto_set_mode()\n self.assertEqual(t.get_mode(), 'cool')\n\nclass ThermostatTestAutoCheckConflict(unittest.TestCase):\n def test_auto_check_conflict_1(self):\n t = Thermostat(30, 25, 'cool')\n self.assertTrue(t.auto_check_conflict())\n\n def test_auto_check_conflict_2(self):\n t = Thermostat(30, 25, 'heat')\n self.assertFalse(t.auto_check_conflict())\n self.assertEqual(t.mode, 'cool')\n\n def test_auto_check_conflict_3(self):\n t = Thermostat(25, 30, 'heat')\n self.assertTrue(t.auto_check_conflict())\n\n def test_auto_check_conflict_4(self):\n t = Thermostat(25, 30, 'cool')\n self.assertFalse(t.auto_check_conflict())\n self.assertEqual(t.mode, 'heat')\n\n def test_auto_check_conflict_5(self):\n t = Thermostat(25, 25, 'cool')\n self.assertFalse(t.auto_check_conflict())\n self.assertEqual(t.mode, 'cool')\n\n\nclass ThermostatTestSimulateOperation(unittest.TestCase):\n def test_simulate_operation_1(self):\n t = Thermostat(20, 25, 'heat')\n self.assertEqual(t.simulate_operation(), 5)\n self.assertEqual(t.get_mode(), 'heat')\n self.assertEqual(t.current_temperature, 25)\n\n def test_simulate_operation_2(self):\n t = Thermostat(25.7, 20, 'cool')\n self.assertEqual(t.simulate_operation(), 6)\n self.assertEqual(t.get_mode(), 'cool')\n self.assertEqual(t.current_temperature, 19.7)\n\n def test_simulate_operation_3(self):\n t = Thermostat(25, 25, 'heat')\n self.assertEqual(t.simulate_operation(), 0)\n self.assertEqual(t.get_mode(), 'cool')\n self.assertEqual(t.current_temperature, 25)\n\n def test_simulate_operation_4(self):\n t = Thermostat(25, 25, 'cool')\n self.assertEqual(t.simulate_operation(), 0)\n self.assertEqual(t.get_mode(), 'cool')\n self.assertEqual(t.current_temperature, 25)\n\n def test_simulate_operation_5(self):\n t = Thermostat(25, 25, 'test')\n self.assertEqual(t.simulate_operation(), 0)\n self.assertEqual(t.get_mode(), 'cool')\n self.assertEqual(t.current_temperature, 25)\n\nclass ThermostatTestMain(unittest.TestCase):\n def test_main(self):\n t = Thermostat(20, 37.5, 'cool')\n self.assertEqual(t.get_target_temperature(), 37.5)\n\n t.set_target_temperature(37.6)\n self.assertEqual(t.target_temperature, 37.6)\n\n self.assertEqual(t.get_mode(), 'cool')\n self.assertFalse(t.set_mode('test'))\n\n self.assertFalse(t.auto_check_conflict())\n self.assertEqual(t.get_mode(), 'heat')\n self.assertEqual(t.simulate_operation(), 18)"} {"task_id": "DREval/146", "entry_point": "TriCalculator", "code": "from math import pi, fabs\n\n\nclass TriCalculator:\n\n def __init__(self):\n pass\n\n def cos(self, x):\n return round(self.taylor(x, 50), 10)\n\n def factorial(self, a):\n b = 1\n while a != 1:\n b *= a\n a -= 1\n return b\n\n def taylor(self, x, n):\n a = 1\n x = x / 180 * pi\n count = 1\n for k in range(1, n):\n if count % 2 != 0:\n a -= (x ** (2 * k)) / self.factorial(2 * k)\n else:\n a += (x ** (2 * k)) / self.factorial(2 * k)\n count += 1\n return a\n\n def sin(self, x):\n x = x / 180 * pi\n g = 0\n t = x\n n = 1\n\n while fabs(t) >= 1e-15:\n g += t\n n += 1\n t = -t * x * x / (2 * n - 1) / (2 * n - 2)\n return round(g, 10)\n\n def tan(self, x):\n if self.cos(x) != 0:\n result = self.sin(x) / self.cos(x)\n return round(result, 10)\n else:\n return False", "inputs": ["tricalculator = TriCalculator()\nassertEqual(tricalculator.cos(60), 0.5)\n", "tricalculator = TriCalculator()\nassertEqual(tricalculator.factorial(5), 120)\n", "tricalculator = TriCalculator()\nassertAlmostEqual(tricalculator.taylor(60, 50), 0.5)\n", "tricalculator = TriCalculator()\nassertEqual(tricalculator.sin(30), 0.5)\n", "tricalculator = TriCalculator()\nassertEqual(tricalculator.tan(45), 1.0)\n", "tricalculator = TriCalculator()\nassertEqual(tricalculator.cos(60), 0.5)\nassertAlmostEqual(tricalculator.taylor(60, 50), 0.5)\nassertEqual(tricalculator.sin(30), 0.5)\nassertEqual(tricalculator.tan(45), 1.0)\nassertEqual(tricalculator.tan(90), False)\n"], "outputs": [], "test": "import unittest\n\n\nclass TriCalculatorTestCos(unittest.TestCase):\n def test_cos_1(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.cos(60), 0.5)\n\n def test_cos_2(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.cos(30), 0.8660254038)\n\n def test_cos_3(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.cos(0), 1.0)\n\n def test_cos_4(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.cos(90), 0.0)\n\n def test_cos_5(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.cos(45), 0.7071067812)\n\n\nclass TriCalculatorTestFactorial(unittest.TestCase):\n def test_factorial_1(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.factorial(5), 120)\n\n def test_factorial_2(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.factorial(4), 24)\n\n def test_factorial_3(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.factorial(3), 6)\n\n def test_factorial_4(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.factorial(2), 2)\n\n def test_factorial_5(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.factorial(1), 1)\n\n\nclass TriCalculatorTestTaylor(unittest.TestCase):\n def test_taylor_1(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.taylor(60, 50), 0.5)\n\n def test_taylor_2(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.taylor(30, 50), 0.8660254037844386)\n\n def test_taylor_3(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.taylor(90, 50), 0.0)\n\n def test_taylor_4(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.taylor(0, 50), 1.0)\n\n def test_taylor_5(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.taylor(45, 50), 0.7071067811865475)\n\n\nclass TriCalculatorTestSin(unittest.TestCase):\n def test_sin_1(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.sin(30), 0.5)\n\n def test_sin_2(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.sin(60), 0.8660254038)\n\n def test_sin_3(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.sin(0), 0.0)\n\n def test_sin_4(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.sin(90), 1.0)\n\n def test_sin_5(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.sin(45), 0.7071067812)\n\n\nclass TriCalculatorTestTan(unittest.TestCase):\n def test_tan_1(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.tan(45), 1.0)\n\n def test_tan_2(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.tan(90), False)\n\n def test_tan_3(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.tan(30), 0.5773502692)\n\n def test_tan_4(self):\n tricalculator = TriCalculator()\n self.assertAlmostEqual(tricalculator.tan(60), 1.7320508076)\n\n def test_tan_5(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.tan(0), 0.0)\n\n\nclass TriCalculatorTest(unittest.TestCase):\n def test_tricalculator(self):\n tricalculator = TriCalculator()\n self.assertEqual(tricalculator.cos(60), 0.5)\n self.assertAlmostEqual(tricalculator.taylor(60, 50), 0.5)\n self.assertEqual(tricalculator.sin(30), 0.5)\n self.assertEqual(tricalculator.tan(45), 1.0)\n self.assertEqual(tricalculator.tan(90), False)"} {"task_id": "DREval/147", "entry_point": "URLHandler", "code": "class URLHandler:\n def __init__(self, url):\n self.url = url\n\n def get_scheme(self):\n scheme_end = self.url.find(\"://\")\n if scheme_end != -1:\n return self.url[:scheme_end]\n return None\n\n def get_host(self):\n scheme_end = self.url.find(\"://\")\n if scheme_end != -1:\n url_without_scheme = self.url[scheme_end + 3:]\n host_end = url_without_scheme.find(\"/\")\n if host_end != -1:\n return url_without_scheme[:host_end]\n return url_without_scheme\n return None\n\n def get_path(self):\n scheme_end = self.url.find(\"://\")\n if scheme_end != -1:\n url_without_scheme = self.url[scheme_end + 3:]\n host_end = url_without_scheme.find(\"/\")\n if host_end != -1:\n return url_without_scheme[host_end:]\n return None\n\n def get_query_params(self):\n query_start = self.url.find(\"?\")\n fragment_start = self.url.find(\"#\")\n if query_start != -1:\n query_string = self.url[query_start + 1:fragment_start]\n params = {}\n if len(query_string) > 0:\n param_pairs = query_string.split(\"&\")\n for pair in param_pairs:\n key_value = pair.split(\"=\")\n if len(key_value) == 2:\n key, value = key_value\n params[key] = value\n return params\n return None\n\n def get_fragment(self):\n fragment_start = self.url.find(\"#\")\n if fragment_start != -1:\n return self.url[fragment_start + 1:]\n return None", "inputs": ["urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\ntemp = urlhandler.get_scheme()\nassertEqual(temp, \"https\")\n", "urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\ntemp = urlhandler.get_host()\nassertEqual(temp, \"www.baidu.com\")\n", "urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\ntemp = urlhandler.get_path()\nassertEqual(temp, \"/s?wd=aaa&rsv_spt=1#page\")\n", "urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\ntemp = urlhandler.get_query_params()\nassertEqual(temp, {\"wd\": \"aaa\", \"rsv_spt\": \"1\"})\n", "urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\ntemp = urlhandler.get_fragment()\nassertEqual(temp, \"page\")\n", "urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\ntemp = urlhandler.get_scheme()\nassertEqual(temp, \"https\")\ntemp = urlhandler.get_host()\nassertEqual(temp, \"www.baidu.com\")\ntemp = urlhandler.get_path()\nassertEqual(temp, \"/s?wd=aaa&rsv_spt=1#page\")\ntemp = urlhandler.get_query_params()\nassertEqual(temp, {\"wd\": \"aaa\", \"rsv_spt\": \"1\"})\ntemp = urlhandler.get_fragment()\nassertEqual(temp, \"page\")\n"], "outputs": [], "test": "import unittest\n\n\nclass URLHandlerTestGetScheme(unittest.TestCase):\n def test_get_scheme_1(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n temp = urlhandler.get_scheme()\n self.assertEqual(temp, \"https\")\n\n def test_get_scheme_2(self):\n urlhandler = URLHandler(\n \"https://www.bing.com/search?pglt=41&q=humaneval&cvid=4dc2da2bb4bc429eb498c85245ae5253&aqs=edge.0.0l7j69i61j69i60.10008j0j1&FORM=ANNTA1&PC=U531&mkt=zh-CN\")\n temp = urlhandler.get_scheme()\n self.assertEqual(temp, \"https\")\n\n def test_get_scheme_3(self):\n urlhandler = URLHandler(\"https://github.com/openai/human-eval\")\n temp = urlhandler.get_scheme()\n self.assertEqual(temp, \"https\")\n\n def test_get_scheme_4(self):\n urlhandler = URLHandler(\"aaa://github.com/openai/human-eval\")\n temp = urlhandler.get_scheme()\n self.assertEqual(temp, \"aaa\")\n\n def test_get_scheme_5(self):\n urlhandler = URLHandler(\"bbb://github.com/openai/human-eval\")\n temp = urlhandler.get_scheme()\n self.assertEqual(temp, \"bbb\")\n\n def test_get_scheme_6(self):\n urlhandler = URLHandler(\"abcdefg\")\n temp = urlhandler.get_scheme()\n self.assertIsNone(temp)\n\n\nclass URLHandlerTestGetHost(unittest.TestCase):\n def test_get_host_1(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"www.baidu.com\")\n\n def test_get_host_2(self):\n urlhandler = URLHandler(\n \"https://www.bing.com/search?pglt=41&q=humaneval&cvid=4dc2da2bb4bc429eb498c85245ae5253&aqs=edge.0.0l7j69i61j69i60.10008j0j1&FORM=ANNTA1&PC=U531&mkt=zh-CN\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"www.bing.com\")\n\n def test_get_host_3(self):\n urlhandler = URLHandler(\"https://github.com/openai/human-eval\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"github.com\")\n\n def test_get_host_4(self):\n urlhandler = URLHandler(\"https://aaa.com/openai/human-eval\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"aaa.com\")\n\n def test_get_host_5(self):\n urlhandler = URLHandler(\"https://bbb.com/openai/human-eval\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"bbb.com\")\n\n def test_get_host_6(self):\n urlhandler = URLHandler(\"abcdefg\")\n temp = urlhandler.get_host()\n self.assertIsNone(temp)\n\n def test_get_host_7(self):\n urlhandler = URLHandler(\"https://bbb.com\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"bbb.com\")\n\n def test_get_host_8(self):\n urlhandler = URLHandler(\"https://bbb.com/\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"bbb.com\")\n\n\nclass URLHandlerTestGetPath(unittest.TestCase):\n def test_get_path_1(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n temp = urlhandler.get_path()\n self.assertEqual(temp, \"/s?wd=aaa&rsv_spt=1#page\")\n\n def test_get_path_2(self):\n urlhandler = URLHandler(\n \"https://www.bing.com/search?pglt=41&q=humaneval&cvid=4dc2da2bb4bc429eb498c85245ae5253&aqs=edge.0.0l7j69i61j69i60.10008j0j1&FORM=ANNTA1&PC=U531&mkt=zh-CN\")\n temp = urlhandler.get_path()\n self.assertEqual(temp,\n \"/search?pglt=41&q=humaneval&cvid=4dc2da2bb4bc429eb498c85245ae5253&aqs=edge.0.0l7j69i61j69i60.10008j0j1&FORM=ANNTA1&PC=U531&mkt=zh-CN\")\n\n def test_get_path_3(self):\n urlhandler = URLHandler(\"https://github.com/openai/human-eval\")\n temp = urlhandler.get_path()\n self.assertEqual(temp, \"/openai/human-eval\")\n\n def test_get_path_4(self):\n urlhandler = URLHandler(\"https://github.com/aaa/human-eval\")\n temp = urlhandler.get_path()\n self.assertEqual(temp, \"/aaa/human-eval\")\n\n def test_get_path_5(self):\n urlhandler = URLHandler(\"https://github.com/bbb/human-eval\")\n temp = urlhandler.get_path()\n self.assertEqual(temp, \"/bbb/human-eval\")\n\n def test_get_path_6(self):\n urlhandler = URLHandler(\"abcdefg\")\n temp = urlhandler.get_path()\n self.assertIsNone(temp)\n\n\nclass URLHandlerTestGetQueryParams(unittest.TestCase):\n def test_get_query_params_1(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, {\"wd\": \"aaa\", \"rsv_spt\": \"1\"})\n\n def test_get_query_params_2(self):\n urlhandler = URLHandler(\n \"https://www.bing.com/search?pglt=41&q=humaneval&cvid=4dc2da2bb4bc429eb498c85245ae5253&aqs=edge.0.0l7j69i61j69i60.10008j0j1&FORM=ANNTA1&PC=U531#\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, {\"pglt\": \"41\", \"q\": \"humaneval\", \"cvid\": \"4dc2da2bb4bc429eb498c85245ae5253\",\n \"aqs\": \"edge.0.0l7j69i61j69i60.10008j0j1\", \"FORM\": \"ANNTA1\", \"PC\": \"U531\"})\n\n def test_get_query_params_3(self):\n urlhandler = URLHandler(\"https://github.com/openai/human-eval\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, None)\n\n def test_get_query_params_4(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=bbb&rsv_spt=1#page\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, {\"wd\": \"bbb\", \"rsv_spt\": \"1\"})\n\n def test_get_query_params_5(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=ccc&rsv_spt=1#page\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, {\"wd\": \"ccc\", \"rsv_spt\": \"1\"})\n\n def test_get_query_params_6(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?&#page\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, {})\n\n\nclass URLHandlerTestGetFragment(unittest.TestCase):\n def test_get_fragment_1(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n temp = urlhandler.get_fragment()\n self.assertEqual(temp, \"page\")\n\n def test_get_fragment_2(self):\n urlhandler = URLHandler(\n \"https://www.bing.com/search?pglt=41&q=humaneval&cvid=4dc2da2bb4bc429eb498c85245ae5253&aqs=edge.0.0l7j69i61j69i60.10008j0j1&FORM=ANNTA1&PC=U531&mkt=zh-CN\")\n temp = urlhandler.get_fragment()\n self.assertEqual(temp, None)\n\n def test_get_fragment_3(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#aaa\")\n temp = urlhandler.get_fragment()\n self.assertEqual(temp, \"aaa\")\n\n def test_get_fragment_4(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#bbb\")\n temp = urlhandler.get_fragment()\n self.assertEqual(temp, \"bbb\")\n\n def test_get_fragment_5(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#ccc\")\n temp = urlhandler.get_fragment()\n self.assertEqual(temp, \"ccc\")\n\n\nclass URLHandlerTest(unittest.TestCase):\n def test_urlhandler(self):\n urlhandler = URLHandler(\"https://www.baidu.com/s?wd=aaa&rsv_spt=1#page\")\n temp = urlhandler.get_scheme()\n self.assertEqual(temp, \"https\")\n temp = urlhandler.get_host()\n self.assertEqual(temp, \"www.baidu.com\")\n temp = urlhandler.get_path()\n self.assertEqual(temp, \"/s?wd=aaa&rsv_spt=1#page\")\n temp = urlhandler.get_query_params()\n self.assertEqual(temp, {\"wd\": \"aaa\", \"rsv_spt\": \"1\"})\n temp = urlhandler.get_fragment()\n self.assertEqual(temp, \"page\")"} {"task_id": "DREval/148", "entry_point": "UrlPath", "code": "import urllib.parse\n\n\nclass UrlPath:\n def __init__(self):\n self.segments = []\n self.with_end_tag = False\n\n def add(self, segment):\n self.segments.append(self.fix_path(segment))\n\n def parse(self, path, charset):\n if path:\n if path.endswith('/'):\n self.with_end_tag = True\n\n path = self.fix_path(path)\n if path:\n split = path.split('/')\n for seg in split:\n decoded_seg = urllib.parse.unquote(seg, encoding=charset)\n self.segments.append(decoded_seg)\n\n @staticmethod\n def fix_path(path):\n if not path:\n return ''\n\n segment_str = path.strip('/')\n return segment_str", "inputs": ["url_path = UrlPath()\nurl_path.add('foo')\nurl_path.add('bar')\nassertEqual(url_path.segments, ['foo', 'bar'])\n", "url_path = UrlPath()\nurl_path.parse('/foo/bar/', 'utf-8')\nassertEqual(url_path.segments, ['foo', 'bar'])\nassertEqual(url_path.with_end_tag, True)\n", "fixed_path = UrlPath.fix_path('/foo/bar/')\nassertEqual(fixed_path, 'foo/bar')\n", "url_path = UrlPath()\nurl_path.add('foo')\nurl_path.add('bar')\nassertEqual(url_path.segments, ['foo', 'bar'])\nurl_path = UrlPath()\nurl_path.parse('/foo/bar/', 'utf-8')\nassertEqual(url_path.segments, ['foo', 'bar'])\nassertEqual(url_path.with_end_tag, True)\nfixed_path = UrlPath.fix_path('/foo/bar/')\nassertEqual(fixed_path, 'foo/bar')\n"], "outputs": [], "test": "import unittest\n\n\nclass UrlPathTestAdd(unittest.TestCase):\n def test_add_1(self):\n url_path = UrlPath()\n url_path.add('foo')\n url_path.add('bar')\n self.assertEqual(url_path.segments, ['foo', 'bar'])\n\n def test_add_2(self):\n url_path = UrlPath()\n url_path.add('aaa')\n url_path.add('bbb')\n self.assertEqual(url_path.segments, ['aaa', 'bbb'])\n\n def test_add_3(self):\n url_path = UrlPath()\n url_path.add('123')\n self.assertEqual(url_path.segments, ['123'])\n\n def test_add_4(self):\n url_path = UrlPath()\n url_path.add('ddd')\n self.assertEqual(url_path.segments, ['ddd'])\n\n def test_add_5(self):\n url_path = UrlPath()\n url_path.add('eee')\n self.assertEqual(url_path.segments, ['eee'])\n\n\nclass UrlPathTestParse(unittest.TestCase):\n def test_parse_1(self):\n url_path = UrlPath()\n url_path.parse('/foo/bar/', 'utf-8')\n self.assertEqual(url_path.segments, ['foo', 'bar'])\n self.assertEqual(url_path.with_end_tag, True)\n\n def test_parse_2(self):\n url_path = UrlPath()\n url_path.parse('aaa/bbb', 'utf-8')\n self.assertEqual(url_path.segments, ['aaa', 'bbb'])\n self.assertEqual(url_path.with_end_tag, False)\n\n def test_parse_3(self):\n url_path = UrlPath()\n url_path.parse('/123/456/', 'utf-8')\n self.assertEqual(url_path.segments, ['123', '456'])\n self.assertEqual(url_path.with_end_tag, True)\n\n def test_parse_4(self):\n url_path = UrlPath()\n url_path.parse('/123/456/789', 'utf-8')\n self.assertEqual(url_path.segments, ['123', '456', '789'])\n self.assertEqual(url_path.with_end_tag, False)\n\n def test_parse_5(self):\n url_path = UrlPath()\n url_path.parse('/foo/bar', 'utf-8')\n self.assertEqual(url_path.segments, ['foo', 'bar'])\n self.assertEqual(url_path.with_end_tag, False)\n\n def test_parse_6(self):\n url_path = UrlPath()\n url_path.parse('', 'utf-8')\n self.assertEqual(url_path.segments, [])\n self.assertEqual(url_path.with_end_tag, False)\n\n def test_parse_7(self):\n url_path = UrlPath()\n url_path.parse('//', 'utf-8')\n self.assertEqual(url_path.segments, [])\n self.assertEqual(url_path.with_end_tag, True)\n\n\nclass UrlPathTestFixPath(unittest.TestCase):\n def test_fix_path_1(self):\n fixed_path = UrlPath.fix_path('/foo/bar/')\n self.assertEqual(fixed_path, 'foo/bar')\n\n def test_fix_path_2(self):\n fixed_path = UrlPath.fix_path('/aaa/bbb/')\n self.assertEqual(fixed_path, 'aaa/bbb')\n\n def test_fix_path_3(self):\n fixed_path = UrlPath.fix_path('/a/b/')\n self.assertEqual(fixed_path, 'a/b')\n\n def test_fix_path_4(self):\n fixed_path = UrlPath.fix_path('/111/222/')\n self.assertEqual(fixed_path, '111/222')\n\n def test_fix_path_5(self):\n fixed_path = UrlPath.fix_path('/a/')\n self.assertEqual(fixed_path, 'a')\n\n def test_fix_path_6(self):\n fixed_path = UrlPath.fix_path('')\n self.assertEqual(fixed_path, '')\n\n\nclass UrlPathTest(unittest.TestCase):\n def test_urlpath(self):\n url_path = UrlPath()\n url_path.add('foo')\n url_path.add('bar')\n self.assertEqual(url_path.segments, ['foo', 'bar'])\n\n url_path = UrlPath()\n url_path.parse('/foo/bar/', 'utf-8')\n self.assertEqual(url_path.segments, ['foo', 'bar'])\n self.assertEqual(url_path.with_end_tag, True)\n\n fixed_path = UrlPath.fix_path('/foo/bar/')\n self.assertEqual(fixed_path, 'foo/bar')"} {"task_id": "DREval/149", "entry_point": "VectorUtil", "code": "import numpy as np\nfrom gensim import matutils\nfrom numpy import dot, array\n\n\nclass VectorUtil:\n @staticmethod\n def similarity(vector_1, vector_2):\n return dot(matutils.unitvec(vector_1), matutils.unitvec(vector_2))\n\n @staticmethod\n def cosine_similarities(vector_1, vectors_all):\n norm = np.linalg.norm(vector_1)\n all_norms = np.linalg.norm(vectors_all, axis=1)\n dot_products = dot(vectors_all, vector_1)\n similarities = dot_products / (norm * all_norms)\n return similarities\n\n @staticmethod\n def n_similarity(vector_list_1, vector_list_2):\n if not (len(vector_list_1) and len(vector_list_2)):\n raise ZeroDivisionError('At least one of the passed list is empty.')\n\n return dot(matutils.unitvec(array(vector_list_1).mean(axis=0)),\n matutils.unitvec(array(vector_list_2).mean(axis=0)))\n\n @staticmethod\n def compute_idf_weight_dict(total_num, number_dict):\n index_2_key_map = {}\n\n index = 0\n\n count_list = []\n for key, count in number_dict.items():\n index_2_key_map[index] = key\n count_list.append(count)\n index = index + 1\n\n a = np.array(count_list)\n ## smooth, in case the divide by zero error\n a = np.log((total_num + 1) / (a + 1))\n result = {}\n\n for index, w in enumerate(a):\n key = index_2_key_map[index]\n result[key] = w\n\n return result", "inputs": ["vector_1 = np.array([1, 1])\nvector_2 = np.array([1, 0])\nsimilarity = VectorUtil.similarity(vector_1, vector_2)\nassertAlmostEqual(similarity, 0.7071067811865475)\n", "vector1 = np.array([1, 1])\nvectors_all = [np.array([1, 0]), np.array([1, 1])]\nsimilarities = VectorUtil.cosine_similarities(vector1, vectors_all)\nres = [0.7071067811865475, 1.0]\nfor index, item in enumerate(similarities):\n\tassertAlmostEqual(item, res[index])\n", "vector_list1 = [np.array([1, 0]), np.array([0, 1])]\nvector_list2 = [np.array([0, 0]), np.array([1, 1])]\nsimilarity = VectorUtil.n_similarity(vector_list1, vector_list2)\nassertAlmostEqual(similarity, 1.0)\n", "num_dict = {'key1': 0.1, 'key2': 0.5}\nres = VectorUtil.compute_idf_weight_dict(2, num_dict)\nassertAlmostEqual(res['key1'], 1.0033021088637848)\nassertAlmostEqual(res['key2'], 0.6931471805599453)\n", "vector_1 = np.array([1, 1])\nvector_2 = np.array([1, 0])\nsimilarity = VectorUtil.similarity(vector_1, vector_2)\nassertAlmostEqual(similarity, 0.7071067811865475)\nvector1 = np.array([1, 1])\nvectors_all = [np.array([1, 0]), np.array([1, 1])]\nsimilarities = VectorUtil.cosine_similarities(vector1, vectors_all)\nres = [0.7071067811865475, 1.0]\nfor index, item in enumerate(similarities):\n\tassertAlmostEqual(item, res[index])\nvector_list1 = [np.array([1, 0]), np.array([0, 1])]\nvector_list2 = [np.array([0, 0]), np.array([1, 1])]\nsimilarity = VectorUtil.n_similarity(vector_list1, vector_list2)\nassertAlmostEqual(similarity, 1.0)\nnum_dict = {'key1': 0.1, 'key2': 0.5}\nres = VectorUtil.compute_idf_weight_dict(2, num_dict)\nassertAlmostEqual(res['key1'], 1.0033021088637848)\nassertAlmostEqual(res['key2'], 0.6931471805599453)\n"], "outputs": [], "test": "import unittest\n\n\nclass VectorUtilTestSimilarity(unittest.TestCase):\n def test_similarity_1(self):\n vector_1 = np.array([1, 1])\n vector_2 = np.array([1, 0])\n similarity = VectorUtil.similarity(vector_1, vector_2)\n self.assertAlmostEqual(similarity, 0.7071067811865475)\n\n def test_similarity_2(self):\n vector_1 = np.array([1, 1])\n vector_2 = np.array([0, 0])\n similarity = VectorUtil.similarity(vector_1, vector_2)\n self.assertAlmostEqual(similarity, 0.0)\n\n def test_similarity_3(self):\n vector_1 = np.array([1, 1])\n vector_2 = np.array([1, 1])\n similarity = VectorUtil.similarity(vector_1, vector_2)\n self.assertAlmostEqual(similarity, 1.0)\n\n def test_similarity_4(self):\n vector_1 = np.array([1, 1, 0, 1, 0, 1, 0, 1])\n vector_2 = np.array([1, 0, 0, 1, 0, 1, 0, 1])\n similarity = VectorUtil.similarity(vector_1, vector_2)\n self.assertAlmostEqual(similarity, 0.8944271909999159)\n\n def test_similarity_5(self):\n vector_1 = np.array([1, 1, 1, 1, 1, 1, 1, 1])\n vector_2 = np.array([0, 0, 0, 0, 0, 0, 0, 0])\n similarity = VectorUtil.similarity(vector_1, vector_2)\n self.assertAlmostEqual(similarity, 0.0)\n\n\nclass VectorUtilTestCosineSimilarities(unittest.TestCase):\n def test_cosine_similarities_1(self):\n vector1 = np.array([1, 1])\n vectors_all = [np.array([1, 0]), np.array([1, 1])]\n similarities = VectorUtil.cosine_similarities(vector1, vectors_all)\n res = [0.7071067811865475, 1.0]\n for index, item in enumerate(similarities):\n self.assertAlmostEqual(item, res[index])\n\n def test_cosine_similarities_2(self):\n vector1 = np.array([1, 1, 0, 0, 1, 0, 1, 0])\n vectors_all = [np.array([1, 0, 0, 0, 1, 0, 1, 0]), np.array([1, 1, 0, 1, 1, 1, 1, 0])]\n similarities = VectorUtil.cosine_similarities(vector1, vectors_all)\n res = [0.8660254037844387, 0.8164965809277261]\n for index, item in enumerate(similarities):\n self.assertAlmostEqual(item, res[index])\n\n def test_cosine_similarities_3(self):\n vector1 = np.array([1, 1, 0, 0, 1, 0, 1, 0])\n vectors_all = [np.array([1, 0, 0, 0, 1, 0, 1, 0]), np.array([1, 1, 1, 1, 1, 1, 1, 0])]\n similarities = VectorUtil.cosine_similarities(vector1, vectors_all)\n res = [0.8660254037844387, 0.7559289460184544]\n for index, item in enumerate(similarities):\n self.assertAlmostEqual(item, res[index])\n\n def test_cosine_similarities_4(self):\n vector1 = np.array([1, 1, 0, 0, 1, 0, 1, 0])\n vectors_all = [np.array([1, 0, 0, 0, 1, 0, 1, 0]), np.array([1, 1, 1, 1, 1, 1, 1, 1])]\n similarities = VectorUtil.cosine_similarities(vector1, vectors_all)\n res = [0.8660254037844387, 0.7071067811865475]\n for index, item in enumerate(similarities):\n self.assertAlmostEqual(item, res[index])\n\n def test_cosine_similarities_5(self):\n vector1 = np.array([1, 1, 0, 0, 1, 0, 1, 0])\n vectors_all = [np.array([1, 0, 0, 0, 1, 0, 1, 0]), np.array([0, 1, 1, 1, 1, 1, 1, 1])]\n similarities = VectorUtil.cosine_similarities(vector1, vectors_all)\n res = [0.8660254037844387, 0.5669467095138409]\n for index, item in enumerate(similarities):\n self.assertAlmostEqual(item, res[index])\n\n\nclass VectorUtilTestNSimilarity(unittest.TestCase):\n def test_n_similarity_1(self):\n vector_list1 = [np.array([1, 0]), np.array([0, 1])]\n vector_list2 = [np.array([0, 0]), np.array([1, 1])]\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n self.assertAlmostEqual(similarity, 1.0)\n\n def test_n_similarity_2(self):\n vector_list1 = [np.array([1, 1]), np.array([0, 1])]\n vector_list2 = [np.array([0, 0]), np.array([1, 1])]\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n self.assertAlmostEqual(similarity, 0.9486832980505137)\n\n def test_n_similarity_3(self):\n vector_list1 = [np.array([1, 0]), np.array([1, 1])]\n vector_list2 = [np.array([0, 0]), np.array([1, 1])]\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n self.assertAlmostEqual(similarity, 0.9486832980505137)\n\n def test_n_similarity_4(self):\n vector_list1 = [np.array([1, 0]), np.array([0, 1])]\n vector_list2 = [np.array([1, 0]), np.array([1, 1])]\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n self.assertAlmostEqual(similarity, 0.9486832980505137)\n\n def test_n_similarity_5(self):\n vector_list1 = [np.array([1, 0]), np.array([0, 1])]\n vector_list2 = [np.array([0, 1]), np.array([1, 1])]\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n self.assertAlmostEqual(similarity, 0.9486832980505137)\n\n def test_n_similarity_6(self):\n try:\n vector_list1 = []\n vector_list2 = []\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n except:\n pass\n\n\nclass VectorUtilTestComputeIdfWeightDict(unittest.TestCase):\n def test_compute_idf_weight_dict_1(self):\n num_dict = {'key1': 0.1, 'key2': 0.5}\n res = VectorUtil.compute_idf_weight_dict(2, num_dict)\n self.assertAlmostEqual(res['key1'], 1.0033021088637848)\n self.assertAlmostEqual(res['key2'], 0.6931471805599453)\n\n def test_compute_idf_weight_dict_2(self):\n num_dict = {'key1': 0.2, 'key2': 0.5}\n res = VectorUtil.compute_idf_weight_dict(2, num_dict)\n self.assertAlmostEqual(res['key1'], 0.9162907318741551)\n self.assertAlmostEqual(res['key2'], 0.6931471805599453)\n\n def test_compute_idf_weight_dict_3(self):\n num_dict = {'key1': 0.3, 'key2': 0.5}\n res = VectorUtil.compute_idf_weight_dict(2, num_dict)\n self.assertAlmostEqual(res['key1'], 0.8362480242006185)\n self.assertAlmostEqual(res['key2'], 0.6931471805599453)\n\n def test_compute_idf_weight_dict_4(self):\n num_dict = {'key1': 0.4, 'key2': 0.5}\n res = VectorUtil.compute_idf_weight_dict(2, num_dict)\n self.assertAlmostEqual(res['key1'], 0.7621400520468967)\n self.assertAlmostEqual(res['key2'], 0.6931471805599453)\n\n def test_compute_idf_weight_dict_5(self):\n num_dict = {'key1': 0.5, 'key2': 0.5}\n res = VectorUtil.compute_idf_weight_dict(2, num_dict)\n self.assertAlmostEqual(res['key1'], 0.6931471805599453)\n self.assertAlmostEqual(res['key2'], 0.6931471805599453)\n\n\nclass VectorUtilTest(unittest.TestCase):\n def test_vectorutil(self):\n vector_1 = np.array([1, 1])\n vector_2 = np.array([1, 0])\n similarity = VectorUtil.similarity(vector_1, vector_2)\n self.assertAlmostEqual(similarity, 0.7071067811865475)\n\n vector1 = np.array([1, 1])\n vectors_all = [np.array([1, 0]), np.array([1, 1])]\n similarities = VectorUtil.cosine_similarities(vector1, vectors_all)\n res = [0.7071067811865475, 1.0]\n for index, item in enumerate(similarities):\n self.assertAlmostEqual(item, res[index])\n\n vector_list1 = [np.array([1, 0]), np.array([0, 1])]\n vector_list2 = [np.array([0, 0]), np.array([1, 1])]\n similarity = VectorUtil.n_similarity(vector_list1, vector_list2)\n self.assertAlmostEqual(similarity, 1.0)\n\n num_dict = {'key1': 0.1, 'key2': 0.5}\n res = VectorUtil.compute_idf_weight_dict(2, num_dict)\n self.assertAlmostEqual(res['key1'], 1.0033021088637848)\n self.assertAlmostEqual(res['key2'], 0.6931471805599453)"} {"task_id": "DREval/150", "entry_point": "VendingMachine", "code": "class VendingMachine:\n def __init__(self):\n self.inventory = {}\n self.balance = 0\n\n def add_item(self, item_name, price, quantity):\n if not self.restock_item(item_name, quantity):\n self.inventory[item_name] = {'price': price, 'quantity': quantity}\n\n def insert_coin(self, amount):\n self.balance += amount\n return self.balance\n\n def purchase_item(self, item_name):\n if item_name in self.inventory:\n item = self.inventory[item_name]\n if item['quantity'] > 0 and self.balance >= item['price']:\n self.balance -= item['price']\n item['quantity'] -= 1\n return self.balance\n else:\n return False\n else:\n return False\n\n def restock_item(self, item_name, quantity):\n if item_name in self.inventory:\n self.inventory[item_name]['quantity'] += quantity\n return True\n else:\n return False\n\n def display_items(self):\n if not self.inventory:\n return False\n else:\n items = []\n for item_name, item_info in self.inventory.items():\n items.append(f\"{item_name} - ${item_info['price']} [{item_info['quantity']}]\")\n return \"\\n\".join(items)", "inputs": ["vendingMachine = VendingMachine()\nvendingMachine.add_item('Coke', 1.25, 10)\nassertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n", "vendingMachine = VendingMachine()\nassertEqual(vendingMachine.insert_coin(1.25), 1.25)\n", "vendingMachine = VendingMachine()\nvendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\nvendingMachine.balance = 1.25\nassertEqual(vendingMachine.purchase_item('Coke'), 0.0)\nassertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 9}})\n", "vendingMachine = VendingMachine()\nvendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\nassertEqual(vendingMachine.restock_item('Coke', 10), True)\nassertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 20}})\n", "vendingMachine = VendingMachine()\nvendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\nassertEqual(vendingMachine.display_items(), 'Coke - $1.25 [10]')\n", "vendingMachine = VendingMachine()\nassertEqual(vendingMachine.display_items(), False)\nvendingMachine.add_item('Coke', 1.25, 10)\nassertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\nassertEqual(vendingMachine.insert_coin(1.25), 1.25)\nassertEqual(vendingMachine.purchase_item('Coke'), 0.0)\nassertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 9}})\nassertEqual(vendingMachine.purchase_item('Pizza'), False)\nassertEqual(vendingMachine.restock_item('Coke', 10), True)\nassertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 19}})\nassertEqual(vendingMachine.restock_item('Pizza', 10), False)\nassertEqual(vendingMachine.display_items(), 'Coke - $1.25 [19]')\n"], "outputs": [], "test": "import unittest\nclass VendingMachineTestAddItem(unittest.TestCase):\n def test_add_item(self):\n vendingMachine = VendingMachine()\n vendingMachine.add_item('Coke', 1.25, 10)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n\n def test_add_item_2(self):\n vendingMachine = VendingMachine()\n vendingMachine.add_item('Coke', 1.25, 10)\n vendingMachine.add_item('Coke', 1.25, 10)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 20}})\n\n def test_add_item_3(self):\n vendingMachine = VendingMachine()\n vendingMachine.add_item('Coke', 1.25, 10)\n vendingMachine.add_item('Pizza', 1.25, 10)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 10}})\n\n def test_add_item_4(self):\n vendingMachine = VendingMachine()\n vendingMachine.add_item('Coke', 1.25, 10)\n vendingMachine.add_item('Pizza', 1.25, 10)\n vendingMachine.add_item('Pizza', 1.25, 10)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 20}})\n\n def test_add_item_5(self):\n vendingMachine = VendingMachine()\n vendingMachine.add_item('Coke', 1.25, 10)\n vendingMachine.add_item('Pizza', 1.25, 10)\n vendingMachine.add_item('Pizza', 1.25, 10)\n vendingMachine.add_item('Coke', 1.25, 10)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 20}, 'Pizza': {'price': 1.25, 'quantity': 20}})\n\nclass VendingMachineTestInsertCoin(unittest.TestCase):\n def test_insert_coin(self):\n vendingMachine = VendingMachine()\n self.assertEqual(vendingMachine.insert_coin(1.25), 1.25)\n\n def test_insert_coin_2(self):\n vendingMachine = VendingMachine()\n self.assertEqual(vendingMachine.insert_coin(2.5), 2.5)\n\n def test_insert_coin_3(self):\n vendingMachine = VendingMachine()\n vendingMachine.insert_coin(1.25)\n vendingMachine.insert_coin(1.25)\n self.assertEqual(vendingMachine.balance, 2.50)\n\n def test_insert_coin_4(self):\n vendingMachine = VendingMachine()\n vendingMachine.balance = 1.25\n vendingMachine.insert_coin(1.25)\n vendingMachine.insert_coin(1.25)\n vendingMachine.insert_coin(1.25)\n self.assertEqual(vendingMachine.balance, 5.0)\n\n def test_insert_coin_5(self):\n vendingMachine = VendingMachine()\n vendingMachine.balance = 1.25\n vendingMachine.insert_coin(1.25)\n vendingMachine.insert_coin(1.25)\n vendingMachine.insert_coin(1.25)\n vendingMachine.insert_coin(1.25)\n self.assertEqual(vendingMachine.balance, 6.25)\n\nclass VendingMachineTestPurchaseItem(unittest.TestCase):\n def test_purchase_item(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n vendingMachine.balance = 1.25\n self.assertEqual(vendingMachine.purchase_item('Coke'), 0.0)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 9}})\n\n def test_purchase_item_2(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n vendingMachine.balance = 1.25\n self.assertEqual(vendingMachine.purchase_item('Pizza'), False)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n\n def test_purchase_item_3(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n vendingMachine.balance = 0\n self.assertEqual(vendingMachine.purchase_item('Coke'), False)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n\n def test_purchase_item_4(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 0}}\n vendingMachine.balance = 1.25\n self.assertEqual(vendingMachine.purchase_item('Coke'), False)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 0}})\n\n def test_purchase_item_5(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 10}}\n vendingMachine.balance = 1.25\n self.assertEqual(vendingMachine.purchase_item('Pizza'), 0.0)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 9}})\n\nclass VendingMachineTestRestockItem(unittest.TestCase):\n def test_restock_item(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.restock_item('Coke', 10), True)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 20}})\n\n def test_restock_item_2(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.restock_item('Pizza', 10), False)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n\n def test_restock_item_3(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 0}}\n self.assertEqual(vendingMachine.restock_item('Coke', 10), True)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n\n def test_restock_item_4(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.restock_item('Pizza', 10), True)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 20}})\n\n def test_restock_item_5(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.restock_item('Pizza', 0), True)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 10}})\nclass VendingMachineTestDisplayItems(unittest.TestCase):\n def test_display_items(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.display_items(), 'Coke - $1.25 [10]')\n\n def test_display_items_2(self):\n vendingMachine = VendingMachine()\n self.assertEqual(vendingMachine.display_items(), False)\n\n def test_display_items_3(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 10}, 'Pizza': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.display_items(),\"Coke - $1.25 [10]\\nPizza - $1.25 [10]\")\n\n def test_display_items_4(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 0}}\n self.assertEqual(vendingMachine.display_items(), 'Coke - $1.25 [0]')\n\n def test_display_items_5(self):\n vendingMachine = VendingMachine()\n vendingMachine.inventory = {'Coke': {'price': 1.25, 'quantity': 0}, 'Pizza': {'price': 1.25, 'quantity': 10}}\n self.assertEqual(vendingMachine.display_items(), 'Coke - $1.25 [0]\\nPizza - $1.25 [10]')\n\nclass VendingMachineTestMain(unittest.TestCase):\n def test_main(self):\n vendingMachine = VendingMachine()\n self.assertEqual(vendingMachine.display_items(), False)\n vendingMachine.add_item('Coke', 1.25, 10)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n self.assertEqual(vendingMachine.insert_coin(1.25), 1.25)\n self.assertEqual(vendingMachine.purchase_item('Coke'), 0.0)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 9}})\n self.assertEqual(vendingMachine.purchase_item('Pizza'), False)\n self.assertEqual(vendingMachine.restock_item('Coke', 10), True)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 19}})\n self.assertEqual(vendingMachine.restock_item('Pizza', 10), False)\n self.assertEqual(vendingMachine.display_items(), 'Coke - $1.25 [19]')\n\n def test_main_2(self):\n vendingMachine = VendingMachine()\n self.assertEqual(vendingMachine.purchase_item('Coke'), False)\n vendingMachine.add_item('Coke', 1.25, 10)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n self.assertEqual(vendingMachine.restock_item('Pizza', 10), False)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 10}})\n self.assertEqual(vendingMachine.insert_coin(1.25), 1.25)\n self.assertEqual(vendingMachine.purchase_item('Coke'), 0.0)\n self.assertEqual(vendingMachine.inventory, {'Coke': {'price': 1.25, 'quantity': 9}})\n self.assertEqual(vendingMachine.display_items(), 'Coke - $1.25 [9]')"} {"task_id": "DREval/151", "entry_point": "Warehouse", "code": "class Warehouse:\n def __init__(self):\n self.inventory = {} # Product ID: Product\n self.orders = {} # Order ID: Order\n\n def add_product(self, product_id, name, quantity):\n if product_id not in self.inventory:\n self.inventory[product_id] = {'name': name, 'quantity': quantity}\n else:\n self.inventory[product_id]['quantity'] += quantity\n\n def update_product_quantity(self, product_id, quantity):\n if product_id in self.inventory:\n self.inventory[product_id]['quantity'] += quantity\n\n def get_product_quantity(self, product_id):\n if product_id in self.inventory:\n return self.inventory[product_id]['quantity']\n else:\n return False\n\n def create_order(self, order_id, product_id, quantity):\n if self.get_product_quantity(product_id) >= quantity:\n self.update_product_quantity(product_id, -quantity)\n self.orders[order_id] = {'product_id': product_id, 'quantity': quantity, 'status': 'Shipped'}\n else:\n return False\n\n def change_order_status(self, order_id, status):\n if order_id in self.orders:\n self.orders[order_id]['status'] = status\n else:\n return False\n\n def track_order(self, order_id):\n if order_id in self.orders:\n return self.orders[order_id]['status']\n else:\n return False", "inputs": ["warehouse = Warehouse()\nwarehouse.add_product(1, 'product 1', 10)\nassertEqual(warehouse.inventory, {1: {'name': 'product 1', 'quantity': 10}})\n", "warehouse = Warehouse()\nwarehouse.add_product(1, 'product 1', 10)\nwarehouse.update_product_quantity(1, 5)\nassertEqual(warehouse.inventory, {1: {'name': 'product 1', 'quantity': 15}})\n", "warehouse = Warehouse()\nwarehouse.add_product(1, 'product 1', 10)\nassertEqual(warehouse.get_product_quantity(1), 10)\n", "warehouse = Warehouse()\nwarehouse.add_product(1, 'product 1', 10)\nwarehouse.create_order(1, 1, 5)\nassertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 5, 'status': 'Shipped'}})\n", "warehouse = Warehouse()\nwarehouse.add_product(1, 'product 1', 10)\nwarehouse.create_order(1, 1, 5)\nwarehouse.change_order_status(1, 'Delivered')\nassertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 5, 'status': 'Delivered'}})\n", "warehouse = Warehouse()\nwarehouse.add_product(1, 'product 1', 10)\nwarehouse.create_order(1, 1, 5)\nassertEqual(warehouse.track_order(1), 'Shipped')\n", "warehouse = Warehouse()\nwarehouse.add_product(1, 'product 1', 10)\nassertEqual({1: {'name': 'product 1', 'quantity': 10}}, warehouse.inventory)\nwarehouse.update_product_quantity(1, -5)\nassertEqual({1: {'name': 'product 1', 'quantity': 5}}, warehouse.inventory)\nassertEqual(warehouse.get_product_quantity(1), 5)\nwarehouse.create_order(1, 1, 3)\nassertEqual({1: {'product_id': 1, 'quantity': 3, 'status': 'Shipped'}}, warehouse.orders)\nwarehouse.change_order_status(1, 'Delivered')\nassertEqual({1: {'product_id': 1, 'quantity': 3, 'status': 'Delivered'}}, warehouse.orders)\nassertEqual('Delivered', warehouse.track_order(1))\n"], "outputs": [], "test": "import unittest\n\n\nclass WarehouseTestAddProduct(unittest.TestCase):\n def test_add_product_1(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 1', 'quantity': 10}})\n\n def test_add_product_2(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.add_product(2, 'product 2', 5)\n self.assertEqual(warehouse.inventory,\n {1: {'name': 'product 1', 'quantity': 10}, 2: {'name': 'product 2', 'quantity': 5}})\n\n def test_add_product_3(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 3', 10)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 3', 'quantity': 10}})\n\n def test_add_product_4(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 4', 10)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 4', 'quantity': 10}})\n\n def test_add_product_5(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 5', 10)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 5', 'quantity': 10}})\n\n def test_add_product_6(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 5', 10)\n warehouse.add_product(1, 'product 5', 10)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 5', 'quantity': 20}})\n\n\nclass WarehouseTestUpdateProductQuantity(unittest.TestCase):\n def test_update_product_quantity_1(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.update_product_quantity(1, 5)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 1', 'quantity': 15}})\n\n # quantity is negative\n def test_update_product_quantity_2(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.update_product_quantity(1, -5)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 1', 'quantity': 5}})\n\n def test_update_product_quantity_3(self):\n warehouse = Warehouse()\n warehouse.update_product_quantity(1, -5)\n self.assertEqual(warehouse.inventory, {})\n\n def test_update_product_quantity_4(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.update_product_quantity(1, 1)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 1', 'quantity': 11}})\n\n def test_update_product_quantity_5(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.update_product_quantity(1, -9)\n self.assertEqual(warehouse.inventory, {1: {'name': 'product 1', 'quantity': 1}})\n\n\nclass WarehouseTestGetProductQuantity(unittest.TestCase):\n def test_get_product_quantity_1(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n self.assertEqual(warehouse.get_product_quantity(1), 10)\n\n def test_get_product_quantity_2(self):\n warehouse = Warehouse()\n self.assertEqual(warehouse.get_product_quantity(1), False)\n\n def test_get_product_quantity_3(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 5)\n self.assertEqual(warehouse.get_product_quantity(1), 5)\n\n def test_get_product_quantity_4(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 100)\n self.assertEqual(warehouse.get_product_quantity(1), 100)\n\n def test_get_product_quantity_5(self):\n warehouse = Warehouse()\n warehouse.add_product(5, 'product 1', 10)\n self.assertEqual(warehouse.get_product_quantity(5), 10)\n\n\nclass WarehouseTestCreateOrder(unittest.TestCase):\n def test_create_order_1(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.create_order(1, 1, 5)\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 5, 'status': 'Shipped'}})\n\n def test_create_order_2(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n result = warehouse.create_order(1, 1, 15)\n self.assertFalse(result)\n\n def test_create_order_3(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 1)\n warehouse.create_order(1, 1, 1)\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 1, 'status': 'Shipped'}})\n\n def test_create_order_4(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 4', 5)\n warehouse.create_order(1, 1, 5)\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 5, 'status': 'Shipped'}})\n\n def test_create_order_5(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 5', 100)\n warehouse.create_order(1, 1, 50)\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 50, 'status': 'Shipped'}})\n\n\nclass WarehouseTestChangeOrderStatus(unittest.TestCase):\n def test_change_order_status_1(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.create_order(1, 1, 5)\n warehouse.change_order_status(1, 'Delivered')\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 5, 'status': 'Delivered'}})\n\n def test_change_order_status_2(self):\n warehouse = Warehouse()\n result = warehouse.change_order_status(1, 'Delivered')\n self.assertFalse(result)\n\n def test_change_order_status_3(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 3', 5)\n warehouse.create_order(1, 1, 5)\n warehouse.change_order_status(1, 'Delivered')\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 5, 'status': 'Delivered'}})\n\n def test_change_order_status_4(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 4', 100)\n warehouse.create_order(1, 1, 50)\n warehouse.change_order_status(1, 'Delivered')\n self.assertEqual(warehouse.orders, {1: {'product_id': 1, 'quantity': 50, 'status': 'Delivered'}})\n\n def test_change_order_status_5(self):\n warehouse = Warehouse()\n result = warehouse.change_order_status(2, 'Delivered')\n self.assertFalse(result)\n\n\nclass WarehouseTestTrackOrder(unittest.TestCase):\n def test_track_order_1(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n warehouse.create_order(1, 1, 5)\n self.assertEqual(warehouse.track_order(1), 'Shipped')\n\n def test_track_order_2(self):\n warehouse = Warehouse()\n result = warehouse.track_order(1)\n self.assertFalse(result)\n\n def test_track_order_3(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 3', 10)\n warehouse.create_order(1, 1, 1)\n self.assertEqual(warehouse.track_order(1), 'Shipped')\n\n def test_track_order_4(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 4', 100)\n warehouse.create_order(1, 1, 50)\n self.assertEqual(warehouse.track_order(1), 'Shipped')\n\n def test_track_order_5(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 5', 100)\n warehouse.create_order(1, 1, 10)\n self.assertEqual(warehouse.track_order(1), 'Shipped')\n\n\nclass WarehouseTestMain(unittest.TestCase):\n def test_main(self):\n warehouse = Warehouse()\n warehouse.add_product(1, 'product 1', 10)\n self.assertEqual({1: {'name': 'product 1', 'quantity': 10}}, warehouse.inventory)\n\n warehouse.update_product_quantity(1, -5)\n self.assertEqual({1: {'name': 'product 1', 'quantity': 5}}, warehouse.inventory)\n\n self.assertEqual(warehouse.get_product_quantity(1), 5)\n\n warehouse.create_order(1, 1, 3)\n self.assertEqual({1: {'product_id': 1, 'quantity': 3, 'status': 'Shipped'}}, warehouse.orders)\n\n warehouse.change_order_status(1, 'Delivered')\n self.assertEqual({1: {'product_id': 1, 'quantity': 3, 'status': 'Delivered'}}, warehouse.orders)\n\n self.assertEqual('Delivered', warehouse.track_order(1))"} {"task_id": "DREval/152", "entry_point": "WeatherSystem", "code": "class WeatherSystem:\n def __init__(self, city) -> None:\n self.temperature = None\n self.weather = None\n self.city = city\n self.weather_list = {}\n \n def query(self, weather_list, tmp_units = 'celsius'):\n self.weather_list = weather_list\n if self.city not in weather_list:\n return False\n else:\n self.temperature = self.weather_list[self.city]['temperature']\n self.weather = self.weather_list[self.city]['weather']\n if self.weather_list[self.city]['temperature units'] != tmp_units:\n if tmp_units == 'celsius':\n return self.fahrenheit_to_celsius(), self.weather\n elif tmp_units == 'fahrenheit':\n return self.celsius_to_fahrenheit(), self.weather\n else:\n return self.temperature, self.weather\n \n def set_city(self, city):\n self.city = city\n\n def celsius_to_fahrenheit(self):\n return (self.temperature * 9/5) + 32\n\n def fahrenheit_to_celsius(self):\n return (self.temperature - 32) * 5/9", "inputs": ["weatherSystem = WeatherSystem('New York')\nweather_list = {\n'New York': {\n'weather': 'sunny',\n'temperature': 27,\n'temperature units': 'celsius'\n},\n'Beijing': {\n'weather': 'cloudy',\n'temperature': 23,\n'temperature units': 'celsius'\n}\n}\nassertEqual(weatherSystem.query(weather_list), (27, 'sunny'))\n", "weatherSystem = WeatherSystem('New York')\nweatherSystem.set_city('Beijing')\nassertEqual(weatherSystem.city, 'Beijing')\n", "weatherSystem = WeatherSystem('New York')\nweatherSystem.temperature = 27\nassertEqual(weatherSystem.celsius_to_fahrenheit(), 80.6)\n", "weatherSystem = WeatherSystem('New York')\nweatherSystem.temperature = 80.6\nassertEqual(weatherSystem.fahrenheit_to_celsius(), 26.999999999999996)\n", "weatherSystem = WeatherSystem('New York')\nweather_list = {\n'New York': {\n'weather': 'sunny',\n'temperature': 27,\n'temperature units': 'celsius'\n},\n'Beijing': {\n'weather': 'cloudy',\n'temperature': 23,\n'temperature units': 'celsius'\n}\n}\nassertEqual(weatherSystem.query(weather_list), (27, 'sunny'))\nweatherSystem.set_city('Beijing')\nassertEqual(weatherSystem.city, 'Beijing')\nweatherSystem.temperature = 27\nassertEqual(weatherSystem.celsius_to_fahrenheit(), 80.6)\nweatherSystem.temperature = 80.6\nassertEqual(weatherSystem.fahrenheit_to_celsius(), 26.999999999999996)\n"], "outputs": [], "test": "import unittest\n\n\nclass WeatherSystemTestQuery(unittest.TestCase):\n def test_query(self):\n weatherSystem = WeatherSystem('New York')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 27,\n 'temperature units': 'celsius'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 23,\n 'temperature units': 'celsius'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list), (27, 'sunny'))\n\n def test_query_2(self):\n weatherSystem = WeatherSystem('Shanghai')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 27,\n 'temperature units': 'celsius'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 23,\n 'temperature units': 'celsius'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list), False)\n\n def test_query_3(self):\n weatherSystem = WeatherSystem('Beijing')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 27,\n 'temperature units': 'celsius'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 23,\n 'temperature units': 'celsius'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list, 'fahrenheit'), (73.4, 'cloudy'))\n\n def test_query_4(self):\n weatherSystem = WeatherSystem('Beijing')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 73.47,\n 'temperature units': 'fahrenheit'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 73.4,\n 'temperature units': 'fahrenheit'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list, 'celsius'), (23.000000000000004, 'cloudy'))\n\n def test_query_5(self):\n weatherSystem = WeatherSystem('New York')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 80.6,\n 'temperature units': 'fahrenheit'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 23,\n 'temperature units': 'celsius'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list, tmp_units='celsius'), (26.999999999999996, 'sunny'))\n\n def test_query_6(self):\n weatherSystem = WeatherSystem('New York')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 27,\n 'temperature units': 'celsius'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 23,\n 'temperature units': 'celsius'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list, tmp_units='fahrenheit'), (80.6, 'sunny'))\n\n\nclass WeatherSystemTestSetCity(unittest.TestCase):\n def test_set_city(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.set_city('Beijing')\n self.assertEqual(weatherSystem.city, 'Beijing')\n\n def test_set_city_2(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.set_city('Shanghai')\n self.assertEqual(weatherSystem.city, 'Shanghai')\n\n def test_set_city_3(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.set_city('Shanghai')\n self.assertNotEqual(weatherSystem.city, 'Beijing')\n\n def test_set_city_4(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.set_city('Shanghai')\n self.assertNotEqual(weatherSystem.city, 'New York')\n\n def test_set_city_5(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.set_city('Shanghai')\n self.assertNotEqual(weatherSystem.city, 'Tokyo')\n\n\nclass WeatherSystemTestCelsiusToFahrenheit(unittest.TestCase):\n def test_celsius_to_fahrenheit(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 27\n self.assertEqual(weatherSystem.celsius_to_fahrenheit(), 80.6)\n\n def test_celsius_to_fahrenheit_2(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 23\n self.assertEqual(weatherSystem.celsius_to_fahrenheit(), 73.4)\n\n def test_celsius_to_fahrenheit_3(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 23\n self.assertNotEqual(weatherSystem.celsius_to_fahrenheit(), 80.6)\n\n def test_celsius_to_fahrenheit_4(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 27\n self.assertNotEqual(weatherSystem.celsius_to_fahrenheit(), 73.4)\n\n def test_celsius_to_fahrenheit_5(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 27\n self.assertNotEqual(weatherSystem.celsius_to_fahrenheit(), 23)\n\n\nclass WeatherSystemTestFahrenheitToCelsius(unittest.TestCase):\n def test_fahrenheit_to_celsius(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 80.6\n self.assertEqual(weatherSystem.fahrenheit_to_celsius(), 26.999999999999996)\n\n def test_fahrenheit_to_celsius_2(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 73.4\n self.assertEqual(weatherSystem.fahrenheit_to_celsius(), 23.000000000000004)\n\n def test_fahrenheit_to_celsius_3(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 80\n self.assertNotEqual(weatherSystem.fahrenheit_to_celsius(), 23)\n\n def test_fahrenheit_to_celsius_4(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 73\n self.assertNotEqual(weatherSystem.fahrenheit_to_celsius(), 27)\n\n def test_fahrenheit_to_celsius_5(self):\n weatherSystem = WeatherSystem('New York')\n weatherSystem.temperature = 80\n self.assertNotEqual(weatherSystem.fahrenheit_to_celsius(), 27)\n\n\nclass WeatherSystemTestMain(unittest.TestCase):\n def test_main(self):\n weatherSystem = WeatherSystem('New York')\n weather_list = {\n 'New York': {\n 'weather': 'sunny',\n 'temperature': 27,\n 'temperature units': 'celsius'\n },\n 'Beijing': {\n 'weather': 'cloudy',\n 'temperature': 23,\n 'temperature units': 'celsius'\n }\n }\n self.assertEqual(weatherSystem.query(weather_list), (27, 'sunny'))\n weatherSystem.set_city('Beijing')\n self.assertEqual(weatherSystem.city, 'Beijing')\n weatherSystem.temperature = 27\n self.assertEqual(weatherSystem.celsius_to_fahrenheit(), 80.6)\n weatherSystem.temperature = 80.6\n self.assertEqual(weatherSystem.fahrenheit_to_celsius(), 26.999999999999996)"} {"task_id": "DREval/153", "entry_point": "Words2Numbers", "code": "class Words2Numbers:\n\n def __init__(self):\n self.numwords = {}\n self.units = [\n \"zero\", \"one\", \"two\", \"three\", \"four\", \"five\", \"six\", \"seven\", \"eight\",\n \"nine\", \"ten\", \"eleven\", \"twelve\", \"thirteen\", \"fourteen\", \"fifteen\",\n \"sixteen\", \"seventeen\", \"eighteen\", \"nineteen\",\n ]\n self.tens = [\"\", \"\", \"twenty\", \"thirty\", \"forty\", \"fifty\", \"sixty\", \"seventy\", \"eighty\", \"ninety\"]\n self.scales = [\"hundred\", \"thousand\", \"million\", \"billion\", \"trillion\"]\n\n self.numwords[\"and\"] = (1, 0)\n for idx, word in enumerate(self.units):\n self.numwords[word] = (1, idx)\n for idx, word in enumerate(self.tens):\n self.numwords[word] = (1, idx * 10)\n for idx, word in enumerate(self.scales):\n self.numwords[word] = (10 ** (idx * 3 or 2), 0)\n\n self.ordinal_words = {'first': 1, 'second': 2, 'third': 3, 'fifth': 5, 'eighth': 8, 'ninth': 9, 'twelfth': 12}\n self.ordinal_endings = [('ieth', 'y'), ('th', '')]\n\n def text2int(self, textnum):\n textnum = textnum.replace('-', ' ')\n\n current = result = 0\n curstring = \"\"\n onnumber = False\n for word in textnum.split():\n if word in self.ordinal_words:\n scale, increment = (1, self.ordinal_words[word])\n current = current * scale + increment\n onnumber = True\n else:\n for ending, replacement in self.ordinal_endings:\n if word.endswith(ending):\n word = \"%s%s\" % (word[:-len(ending)], replacement)\n\n if word not in self.numwords:\n if onnumber:\n curstring += repr(result + current) + \" \"\n curstring += word + \" \"\n result = current = 0\n onnumber = False\n else:\n scale, increment = self.numwords[word]\n current = current * scale + increment\n if scale > 100:\n result += current\n current = 0\n onnumber = True\n\n if onnumber:\n curstring += repr(result + current)\n\n return curstring\n\n def is_valid_input(self, textnum):\n\n textnum = textnum.replace('-', ' ')\n\n for word in textnum.split():\n if word in self.ordinal_words:\n continue\n else:\n for ending, replacement in self.ordinal_endings:\n if word.endswith(ending):\n word = \"%s%s\" % (word[:-len(ending)], replacement)\n\n if word not in self.numwords:\n return False\n\n return True", "inputs": ["w2n = Words2Numbers()\nassertEqual(w2n.text2int(\"thirty-two\"), \"32\")\n", "w2n = Words2Numbers()\nassertTrue(w2n.is_valid_input(\"twenty-five thousand three hundred and forty-two\"))\n", "w2n = Words2Numbers()\nassertEqual(w2n.is_valid_input(\"seventy two thousand and hundred eleven\"), True)\nassertEqual(w2n.text2int(\"seventy two thousand and hundred eleven\"), \"72011\")\n"], "outputs": [], "test": "import unittest\n\n\nclass Words2NumbersTestText2Int(unittest.TestCase):\n def test_text2int(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.text2int(\"thirty-two\"), \"32\")\n\n def test_text2int2(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.text2int(\"one hundred and twenty-three\"), \"123\")\n\n def test_text2int3(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.text2int(\"two thousand and nineteen\"), \"2019\")\n\n def test_text2int4(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.text2int(\"one hundred and one\"), \"101\")\n\n def test_text2int5(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.text2int(\"one million and eleven\"), \"1000011\")\n\n def test_text2int6(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.text2int(\"one million one hundred sixty-ninth\"), \"1000169\")\n\nclass Words2NumbersTestIsValidInput(unittest.TestCase):\n def test_is_valid_input(self):\n w2n = Words2Numbers()\n self.assertTrue(w2n.is_valid_input(\"twenty-five thousand three hundred and forty-two\"))\n\n def test_is_valid_input2(self):\n w2n = Words2Numbers()\n self.assertTrue(w2n.is_valid_input(\"second hundred and third\"))\n\n def test_is_valid_input3(self):\n w2n = Words2Numbers()\n self.assertTrue(w2n.is_valid_input(\"twenty-fifth thousand three hundred and forty-second\"))\n\n def test_is_valid_input4(self):\n w2n = Words2Numbers()\n self.assertFalse(w2n.is_valid_input(\"eleventy thousand and five\"))\n\n def test_is_valid_input5(self):\n w2n = Words2Numbers()\n self.assertTrue(w2n.is_valid_input(\"seventy two thousand and hundred eleven\"))\n\n def test_is_valid_input6(self):\n w2n = Words2Numbers()\n self.assertTrue(w2n.is_valid_input(\"fifteenth hundred\"))\n\nclass Words2NumbersTestMain(unittest.TestCase):\n def test_main(self):\n w2n = Words2Numbers()\n self.assertEqual(w2n.is_valid_input(\"seventy two thousand and hundred eleven\"), True)\n self.assertEqual(w2n.text2int(\"seventy two thousand and hundred eleven\"), \"72011\")"}