diff --git a/.gitignore b/.gitignore
index 13d9271729c4dad586fe93fced9a21aad28a9c2b..93b41ff5b52a842ab3aee456927faf10d2e920a0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,14 +21,14 @@ cp/tests/unitgrade_data/Week01Palindrome.pkl
 cp/exam
 #cp/project1
 #cp/project2
-cp/project3
+#cp/project3
 cp/project4
 cp/project5
 cp/project6
 cp/tests/tests_week01.py
 #*04*
-*05*
-*06*
+#*05*
+#*06*
 *07*
 *08*
 *09*
diff --git a/cp/ex06/__init__.py b/cp/ex06/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c9bf24e54d475806d511254e677f9f48d430f544
--- /dev/null
+++ b/cp/ex06/__init__.py
@@ -0,0 +1 @@
+"""DO NOT EDIT/ADD TO THIS FILE.""" 
diff --git a/cp/ex06/language.py b/cp/ex06/language.py
new file mode 100644
index 0000000000000000000000000000000000000000..edb86a06e0a2541fefdfef0c370c526fa946af8d
--- /dev/null
+++ b/cp/ex06/language.py
@@ -0,0 +1,19 @@
+"""Exercise 6.5: Languages."""
+
+def get_people_by_language(language: str, name_languages: dict)-> list:
+    """Return the names of people who speak a specific language.
+    
+    :param language: A string containing the desired language.
+    :param name_languages: A dictionary containing the names of people along with their spoken languages
+    :return: The names of people that speak the desired language.
+    """
+    # TODO: Code has been removed from here. 
+if __name__ == "__main__":
+    name_languages = {
+    'Peter': ['Danish', 'English'],
+    'Alice': ['English', 'French'],
+    'John': ['Spanish', 'English'],
+    'Maria': ['Danish', 'Spanish'],
+    'Anna': ['German', 'English']
+    }
+    print(get_people_by_language('English', name_languages))
diff --git a/cp/ex06/letter.py b/cp/ex06/letter.py
new file mode 100644
index 0000000000000000000000000000000000000000..099174638f8e602adfa77941c07ec092a3b250c2
--- /dev/null
+++ b/cp/ex06/letter.py
@@ -0,0 +1,14 @@
+"""Exercise 6.2: Letter histogram."""
+
+def letter_histogram(input_string : str) -> dict:
+    """Return the histogram of letter occurrences.
+    
+    :param input_string: The word based on which the letter histogram is calculated.
+    :return: The alphabet characters as keys with their corresponding occurrences as values.
+    """
+    # TODO: Code has been removed from here. 
+
+
+if __name__ == "__main__":
+    # here you can try out your functions
+    print("What is the letter histogram of the word banana?",  letter_histogram('banana'))
diff --git a/cp/ex06/multi_tap.py b/cp/ex06/multi_tap.py
new file mode 100644
index 0000000000000000000000000000000000000000..aebaba748c0fc0bedc34456e1325d7d31e4aaa54
--- /dev/null
+++ b/cp/ex06/multi_tap.py
@@ -0,0 +1,18 @@
+"""Exercise 6.9: Multi-tap."""
+
+def multi_tap(keys : list, times : list) -> str:
+    """Return the string corresponding to the multi-tap key presses.
+
+    :param keys: The list of keys pressed.
+    :param times: The list of times of when the keys were pressed.
+    :return: The string corresponding to the key presses.
+    """
+    # TODO: Code has been removed from here. 
+    
+
+
+
+if __name__ == "__main__":
+    keys = [7, 7, 7, 7, 6, 6, 6]
+    times = [0, 0.7, 0.8, 0.9, 1, 1.1, 1.2]
+    print(multi_tap(keys, times), '==', 'PRO')
diff --git a/cp/ex06/nato.py b/cp/ex06/nato.py
new file mode 100644
index 0000000000000000000000000000000000000000..455d8d96c0d97993fa40b449c2e71395ed3b1838
--- /dev/null
+++ b/cp/ex06/nato.py
@@ -0,0 +1,13 @@
+"""Exercise 6.1: The NATO alphabet."""
+
+def text_to_nato(plaintext : str) -> str:
+    """Return the NATO version of a word separated by dashes.
+
+    :param plaintext: The word to replace with its phrase according to the NATO alphabet.
+    :return: The NATO representation of the input word.
+    """
+    # TODO: Code has been removed from here. 
+
+if __name__ == "__main__":
+    # here you can try out your functions
+    print("What is the NATO representation of hello?", text_to_nato('hello'))
diff --git a/cp/ex06/sentiment_analysis.py b/cp/ex06/sentiment_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a7402beaa7451d015b6ff369d0130ca10ca7f17
--- /dev/null
+++ b/cp/ex06/sentiment_analysis.py
@@ -0,0 +1,14 @@
+"""Exercise 6.7: Sentiment analysis."""
+
+def sentiment_analysis(text: str) -> int:
+    """Return the sentence sentiment score, according to the rules of words scoring, as described in the text above.
+
+    :param text: The sentence to check for sentiment scoring.
+    :return: The total sentiment scoring of the sentence.
+    """
+    # TODO: Code has been removed from here. 
+
+if __name__ == "__main__":
+    # here you can try out your functions
+    text='I think the food was excellent and great, but the service was horrible '
+    sentiment_analysis(text)
diff --git a/cp/ex06/spell_check.py b/cp/ex06/spell_check.py
new file mode 100644
index 0000000000000000000000000000000000000000..32d33de4df3a5b595b555cc0b91d781d49fa373b
--- /dev/null
+++ b/cp/ex06/spell_check.py
@@ -0,0 +1,23 @@
+"""Exercise 6.8: Spell check."""
+
+def spell_check(text: str, corrections: dict) -> str:
+    """Return the corrected text for spelling errors according to a set of rules.
+
+    :param text: The sentence to check for spelling.
+    :param corrections: The dictionary of wrongly spelled words and their equivalent corrected version.
+    :return: The correctly spelled sentence.
+    """
+    # TODO: Code has been removed from here. 
+
+if __name__ == "__main__":
+    # here you can try out your functions
+    corrections = {
+    'apsolute': 'absolute',
+    'teh': 'the',
+    'acess': 'access', 
+    'occured': 'occurred',
+    'exampel': 'example'
+    }
+    text = "The apsolute acsess to teh data occured in this exampel."
+
+    print(spell_check(text, corrections))
diff --git a/cp/ex06/truncate.py b/cp/ex06/truncate.py
new file mode 100644
index 0000000000000000000000000000000000000000..7731eb660739398fa51af7e15c0247799b994a67
--- /dev/null
+++ b/cp/ex06/truncate.py
@@ -0,0 +1,17 @@
+"""Exercise 6.6: Truncate and normalize."""
+
+def truncate_values(float_list : list, settings: dict) -> list: 
+    """Return a truncated list of floats given the initial list and the settings for truncating. If normalize is True, the values are first normalized to the [0,1] range and then truncated.
+    
+    :param float_list: list of floats
+    :param settings: Dictionary containing the keys vmin, vmax and normalize with their corresponding values.
+    :return: Truncated/Normalized+Truncated values.
+    """
+    # TODO: Code has been removed from here. 
+
+if __name__ == "__main__":
+    # here you can try out your functions
+    settings = {'vmin': 0, 'vmax': 2, 'normalize': False}
+    float_list = [0.5,0.4,-0.3, 1.5, 2.5, 3.5]
+    result=truncate_values(float_list=float_list,settings=settings)
+    print(result)
diff --git a/cp/ex06/word_histogram.py b/cp/ex06/word_histogram.py
new file mode 100644
index 0000000000000000000000000000000000000000..cab8ba1a1c189b2abcdbe0746e8c441389490d51
--- /dev/null
+++ b/cp/ex06/word_histogram.py
@@ -0,0 +1,38 @@
+"""Exercise 6.3-6.4."""
+
+def word_histogram(lines : list) -> list:
+    """Return the word count histogram from the input lines.
+
+    :param lines: The lines that are analyzed for word count.
+    :return: The histogram of word occurrences.
+    """
+    # TODO: Code has been removed from here. 
+    
+def extract_keyword(lines : str, ignore_list : list) -> dict:
+    """Return the five most frequent words that are not on the ignore list and their occurrences.
+
+    :param lines: The sentence to extract keywords from.
+    :param ignore_list: The words that should ignored.
+    :return: The five most frequent words in the sentence as keys with their count as values.
+    """
+    # TODO: Code has been removed from here. 
+
+
+if __name__ == "__main__":
+    # here you can try out your functions
+    print(word_histogram('I think therefore I am.'))
+
+    # Ignore list of common words
+    ignore_list = [
+    'a', 'an', 'the', 'above', 'across', 'against', 'along', 'among', 'around',
+    'at', 'before', 'behind', 'below', 'beneath', 'beside', 'between', 'by',
+    'down', 'from', 'in', 'into', 'near', 'of', 'off', 'on', 'to', 'toward',
+    'under', 'upon', 'with', 'within','function', 'for', 'and', 'nor', 'but', 'or', 'yet', 'so']
+
+    # Example usage:
+    lines = [    "Write the function word_histogram, which takes as argument a list containing lines of a text.",    "The function should ... ... ... ... ... make a histogram of words that occur in the text."]
+
+    keywords_result = extract_keyword(lines, ignore_list)
+
+    # Print the 5 most occurring keywords
+    print(keywords_result)
diff --git a/cp/project3/__init__.py b/cp/project3/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c9bf24e54d475806d511254e677f9f48d430f544
--- /dev/null
+++ b/cp/project3/__init__.py
@@ -0,0 +1 @@
+"""DO NOT EDIT/ADD TO THIS FILE.""" 
diff --git a/cp/project3/project3_grade.py b/cp/project3/project3_grade.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf41c22abaa87ff0b5af54fa592dab7b3e2f629b
--- /dev/null
+++ b/cp/project3/project3_grade.py
@@ -0,0 +1,4 @@
+# cp/project3/project3_tests.py
+''' WARNING: Modifying, decompiling or otherwise tampering with this script, it's data or the resulting .token file will be investigated as a cheating attempt. '''
+import bz2, base64
+exec(bz2.decompress(base64.b64decode('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')))
\ No newline at end of file
diff --git a/cp/project3/project3_tests.py b/cp/project3/project3_tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6755080fa975f2ff734c26b67b65e9b0fecefe3
--- /dev/null
+++ b/cp/project3/project3_tests.py
@@ -0,0 +1,117 @@
+from unitgrade import UTestCase, Report, hide
+import string
+from cp import minput
+from unittest.mock import patch
+import io
+import unittest
+import math
+
+class WaterHeight(UTestCase):
+    def test_water_height(self):
+        from cp.ex05.water_height import water_height
+        self.assertEqual(water_height(5, [1,2,3]), 5)
+        self.assertEqual(water_height(2, [1,1]), 0)
+        self.assertEqual(water_height(0, [1,3]), 1)
+        self.assertEqual(water_height(1,[1,2,3,4,5]),6)
+        self.assertEqual(water_height(2,[1,12,8,4,5]),22)
+        self.assertEqual(water_height(5,[1,10,3,4,5]),18)
+
+class Week05BestBuy(UTestCase):
+    def test_bestbuy(self):
+        from cp.ex05.best_buy import best_buy
+        self.assertEqual(best_buy([3, 2, 1, 3, 5], 10, 0, False), 4)
+        self.assertEqual(best_buy([3, 2, 1, 3, 5], 3, 1, False), 2)
+        self.assertEqual(best_buy([3, 2, 1, 3, 5], 8, 4, True), 2)
+        self.assertEqual(best_buy([3, 2, 1, 3, 5], 15, 4, True), 5)
+
+
+
+class Week05TicTacToePrintBoard(UTestCase):
+    def test_print_board(self):
+        from cp.ex05.tictactoe import print_board
+        with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+            print_board([['-','X','-'],['-','-','O'],['X','-','-']])
+            out = mock_stdout.getvalue().splitlines()
+            self.assertEqual(len(out), 3, msg="You did not print out 3 separate lines")
+            self.assertEqual(out[0], "-X-")
+            self.assertEqual(out[1], "--O")
+            self.assertEqual(out[2], "X--")
+
+class Week05TicTacToeGetGameState(UTestCase):
+    def test_get_game_state(self):
+        from cp.ex05.tictactoe import get_game_state
+        self.assertEqual(get_game_state([['-','-','-'],['-','-','-'],['-','-','-']]),'-') 
+        self.assertEqual(get_game_state([['X','X','X'],['-','-','-'],['-','-','-']]),'X')
+        self.assertEqual(get_game_state([['-','-','-'],['X','X','X'],['-','-','-']]),'X')
+        self.assertEqual(get_game_state([['X','-','-'],['-','X','-'],['O','O','X']]),'X')  
+        self.assertEqual(get_game_state([['X','-','-'],['-','X','-'],['O','O','O']]),'O') 
+        self.assertEqual(get_game_state([['X','O','X'],['X','O','O'],['O','X','X']]),'Draw')
+
+class Week05TicTacToeUpdateBoard(UTestCase):
+    def test_update_board(self):
+        from cp.ex05.tictactoe import update_board
+        with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+            self.assertEqual(update_board([['-','-','-'],['-','-','-'],['-','-','-']],'X',[1,0]),[['-', '-', '-'], ['X', '-', '-'], ['-', '-', '-']])
+            self.assertEqual(update_board([['X','X','-'],['-','-','-'],['-','-','-']],'O',[0,2]),[['X', 'X', 'O'], ['-', '-', '-'], ['-', '-', '-']])
+            self.assertEqual(update_board([['-','-','-'],['X','X','X'],['-','-','-']],'X',[2,0]),[['-', '-', '-'], ['X', 'X', 'X'], ['X', '-', '-']])
+            self.assertEqual(update_board([['X','-','-'],['-','X','-'],['O','O','X']],'O',[1,2]),[['X', '-', '-'], ['-', 'X', 'O'], ['O', 'O', 'X']])  
+            self.assertEqual(update_board([['X','-','-'],['-','X','-'],['O','O','O']],'X',[0,2]),[['X', '-', 'X'], ['-', 'X', '-'], ['O', 'O', 'O']]) 
+            self.assertEqual(update_board([['O','-','-'],['O','X','-'],['O','X','X']],'O',[0,2]),[['O', '-', 'O'], ['O', 'X', '-'], ['O', 'X', 'X']])
+            out = mock_stdout.getvalue()
+            self.assertEqual(out, "", "You should not print anything for valid moves")
+        with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+            update_board([['O','-','-'],['O','X','-'],['O','X','X']],'O',[0,0])
+            out = mock_stdout.getvalue().strip()
+            self.assertEqual(out, "Invalid move!")        
+
+class Week05TicTacToeMain(UTestCase):
+    def test_tictactoe_main(self):
+        from cp.ex05.tictactoe import tictactoe 
+        with unittest.mock.patch('sys.stdout', new=io.StringIO()) as mock_stdout:
+            tictactoe([['X','X','-'],['-','O','-'],['O','-','-']],'O',[0,2])
+            out = mock_stdout.getvalue().splitlines()
+            self.assertEqual(len(out), 4, msg="You did not print out 4 separate lines")
+            self.assertEqual(out[0], "XXO")
+            self.assertEqual(out[1], "-O-")
+            self.assertEqual(out[2], "O--")
+            self.assertEqual(out[3],"Player O won!")
+
+class Week06SentimentAnalysis(UTestCase):
+    def test_sentiment_analysis(self):
+        from cp.ex06.sentiment_analysis import sentiment_analysis
+        self.assertEqual(sentiment_analysis('I think the food was excellent and great, but the waiter service was horrible '),-5)
+        self.assertEqual(sentiment_analysis('When I woke up, I was feeling very bad, but then I had a coffee, and my day turned out to be excellent '),4)
+        self.assertEqual(sentiment_analysis('I know it is good not to complain, but the selection criteria were genuinely inadequate and unfair '),-1)
+
+
+class Week06MultiTap(UTestCase):
+    def test_multi_tap(self):
+        from cp.ex06.multi_tap import multi_tap 
+        self.assertEqual(multi_tap([7, 7, 7, 7, 6, 6, 6], [0, 0.7, 0.8, 0.9, 1, 1.1, 1.2]), 'PRO')
+        self.assertEqual(multi_tap([4, 4, 4, 0, 2, 6, 0, 4, 4, 2, 7, 7, 9, 9, 9], [0.1, 0.3, 0.6, 1.0, 1.2, 1.4, 1.7, 2.0, 2.2, 2.5, 2.9, 3.9, 4.3, 4.4, 4.8]), "I AM HAPPY")
+        self.assertEqual(multi_tap([7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 8, 8, 3], [0.1, 0.5, 0.8, 1.2, 2.6, 3.7, 4.1, 4.2, 4.5, 4.9, 5.1, 5.4, 5.6, 5.9]), "SPROUD")
+        self.assertEqual(multi_tap([4, 4, 4, 2, 2, 2, 3, 3, 0, 4, 4, 4, 2, 2, 2, 3, 3, 0, 2, 2, 2, 2, 2, 9, 9, 9], [0.3, 0.7, 0.8, 1.1, 1.3, 1.5, 1.7, 1.8, 2.1, 2.4, 2.7, 3.0, 3.4, 3.7, 3.9, 4.0, 4.3, 4.5, 4.7, 5.0, 6.4, 7.9, 8.3, 8.5, 8.7, 9.0]), "ICE ICE BABY")
+        self.assertEqual(multi_tap([5, 5, 5, 4, 4, 4, 8, 8, 8, 3, 3, 0, 5, 5, 5, 2, 8, 8, 4, 4, 4, 0, 5, 5, 5, 4, 4, 4, 7, 7, 7, 7, 8], [0.7, 0.9, 1.2, 1.6, 1.7, 2.0, 2.4, 2.5, 2.8, 3.2, 3.5, 3.7, 3.9, 4.3, 4.6, 4.8, 5.0, 5.3, 5.6, 6.3, 6.7, 6.8, 7.1, 7.3, 7.5, 7.8, 8.0, 8.1, 8.3, 8.5, 8.7, 8.9, 9.3]), "LIVE LAUGH LIST")
+
+        
+        
+class Project3(Report):
+    title = "Project 3"
+    remote_url = "https://cp.pages.compute.dtu.dk/02002public/_static/evaluation/"
+
+    abbreviate_questions = True
+    questions = [(Week05BestBuy,10),
+                (WaterHeight,10),
+                (Week05TicTacToePrintBoard,5),
+                (Week05TicTacToeGetGameState,10),
+                (Week05TicTacToeUpdateBoard,10),
+                (Week06SentimentAnalysis,20),
+                (Week06MultiTap,20),
+                ]
+    import cp
+    pack_imports = [cp]
+
+
+if __name__ == "__main__":
+    from unitgrade import evaluate_report_student
+    evaluate_report_student(Project3())
diff --git a/cp/project3/unitgrade_data/WaterHeight.pkl b/cp/project3/unitgrade_data/WaterHeight.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..ce13f8feb9cc18159520688069676c959d9b9733
Binary files /dev/null and b/cp/project3/unitgrade_data/WaterHeight.pkl differ
diff --git a/cp/project3/unitgrade_data/Week05BestBuy.pkl b/cp/project3/unitgrade_data/Week05BestBuy.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..24745ef923dc39c85b64a5187e999786b378850b
Binary files /dev/null and b/cp/project3/unitgrade_data/Week05BestBuy.pkl differ
diff --git a/cp/project3/unitgrade_data/Week05TicTacToeGetGameState.pkl b/cp/project3/unitgrade_data/Week05TicTacToeGetGameState.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..9f8ee114215118ead8e0827be1a9c52495c60a73
Binary files /dev/null and b/cp/project3/unitgrade_data/Week05TicTacToeGetGameState.pkl differ
diff --git a/cp/project3/unitgrade_data/Week05TicTacToePrintBoard.pkl b/cp/project3/unitgrade_data/Week05TicTacToePrintBoard.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..6692f45146f58d46101e58aa0130b526bc8166d4
Binary files /dev/null and b/cp/project3/unitgrade_data/Week05TicTacToePrintBoard.pkl differ
diff --git a/cp/project3/unitgrade_data/Week05TicTacToeUpdateBoard.pkl b/cp/project3/unitgrade_data/Week05TicTacToeUpdateBoard.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..e473fd27c83e2bba49d3c3df24bb21e038978a68
Binary files /dev/null and b/cp/project3/unitgrade_data/Week05TicTacToeUpdateBoard.pkl differ
diff --git a/cp/project3/unitgrade_data/Week06MultiTap.pkl b/cp/project3/unitgrade_data/Week06MultiTap.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..6ca33b7aa3d8e940d32f033632ff5138c10440a5
Binary files /dev/null and b/cp/project3/unitgrade_data/Week06MultiTap.pkl differ
diff --git a/cp/project3/unitgrade_data/Week06SentimentAnalysis.pkl b/cp/project3/unitgrade_data/Week06SentimentAnalysis.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..cef5f2274e1687b74e02715c465b65ae610c6c37
Binary files /dev/null and b/cp/project3/unitgrade_data/Week06SentimentAnalysis.pkl differ
diff --git a/cp/tests/__init__.py b/cp/tests/__init__.py
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..c9bf24e54d475806d511254e677f9f48d430f544 100644
--- a/cp/tests/__init__.py
+++ b/cp/tests/__init__.py
@@ -0,0 +1 @@
+"""DO NOT EDIT/ADD TO THIS FILE.""" 
diff --git a/cp/tests/tests_week06.py b/cp/tests/tests_week06.py
new file mode 100644
index 0000000000000000000000000000000000000000..8169cf4221e85331dc683ffb300aea4a89f4097b
--- /dev/null
+++ b/cp/tests/tests_week06.py
@@ -0,0 +1,129 @@
+from unitgrade import Report
+import cp
+from unitgrade import UTestCase
+
+
+class Week06TextToNato(UTestCase):
+    def test_TextToNato(self):
+        from cp.ex06.nato import text_to_nato
+        self.assertEqual(text_to_nato('Jason'), 'Juliet-Alpha-Sierra-Oscar-November')
+        self.assertEqual(text_to_nato('Spongebob'), 'Sierra-Papa-Oscar-November-Golf-Echo-Bravo-Oscar-Bravo')
+        self.assertEqual(text_to_nato('Oo'), 'Oscar-Oscar')
+        self.assertEqual(text_to_nato('Bubble'), 'Bravo-Uniform-Bravo-Bravo-Lima-Echo')
+        
+class Week06LetterHistogram(UTestCase):
+    def test_LetterHistogram(self):
+        from cp.ex06.letter import letter_histogram
+        self.assertEqual(letter_histogram('The roof is on fire.'),{'a': 0, 'b': 0, 'c': 0, 'd': 0, 'e': 2, 'f': 2, 'g': 0, 'h': 1, 'i': 2, 'j': 0, 'k': 0, 'l': 0, 'm': 0, 'n': 1, 'o': 3, 'p': 0, 'q': 0, 'r': 2, 's': 1, 't': 1, 'u': 0, 'v': 0, 'w': 0, 'x': 0, 'y': 0, 'z': 0} )
+        self.assertEqual(letter_histogram('abcdefghijklmnoprstuvwxyz'),{'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 1, 'f': 1, 'g': 1, 'h': 1, 'i': 1, 'j': 1, 'k': 1, 'l': 1, 'm': 1, 'n': 1, 'o': 1, 'p': 1, 'q': 0, 'r': 1, 's': 1, 't': 1, 'u': 1, 'v': 1, 'w': 1, 'x': 1, 'y': 1, 'z': 1})
+        self.assertEqual(letter_histogram('The name is Bond. James Bond'),{'a': 2, 'b': 2, 'c': 0, 'd': 2, 'e': 3, 'f': 0, 'g': 0, 'h': 1, 'i': 1, 'j': 1, 'k': 0, 'l': 0, 'm': 2, 'n': 3, 'o': 2, 'p': 0, 'q': 0, 'r': 0, 's': 2, 't': 1, 'u': 0, 'v': 0, 'w': 0, 'x': 0, 'y': 0, 'z': 0})
+
+class Week06WordHistogram(UTestCase):
+    def test_WordHistogram(self):
+        from cp.ex06.word_histogram import word_histogram
+        self.assertEqual(word_histogram(["Write the function word_histogram."," which takes as argument a list containing lines of a text."]),{'write': 1, 'the': 1, 'function': 1, 'wordhistogram': 1, 'which': 1, 'takes': 1, 'as': 1, 'argument': 1, 'a': 2, 'list': 1, 'containing': 1, 'lines': 1, 'of': 1, 'text': 1})
+        self.assertEqual(word_histogram(["The function should make a histogram of words that occur in the text.","Punctuation, spaces, numbers, and capitalization should be ignored.",]),{'the': 2, 'function': 1, 'should': 2, 'make': 1, 'a': 1, 'histogram': 1, 'of': 1, 'words': 1, 'that': 1, 'occur': 1, 'in': 1, 'text': 1, 'punctuation': 1, 'spaces': 1, 'numbers': 1, 'and': 1, 'capitalization': 1, 'be': 1, 'ignored': 1})
+        self.assertEqual(word_histogram(["The function should return a dictionary, e.g. {'write': 2, 'the': 12, 'function': 7, …}",]),{'the': 2, 'function': 2, 'should': 1, 'return': 1, 'a': 1, 'dictionary': 1, 'eg': 1, 'write': 1})
+ 
+class Week06ExtractKeywords(UTestCase):
+    def test_ExtractKeywords(self):
+        from cp.ex06.word_histogram import extract_keyword
+        ignore_list = ['a', 'an', 'the', 'above', 'across', 'against', 'along', 'among', 'around',    'at', 'before', 'behind', 'below', 'beneath', 'beside', 'between', 'by',    'down', 'from', 'in', 'into', 'near', 'of', 'off', 'on', 'to', 'toward',    'under', 'upon', 'with', 'within','function', 'for', 'and', 'nor', 'but', 'or', 'yet', 'so']
+        self.assertEqual(extract_keyword(["one two two three three three four four four four five five five five five six six six six six six",], ignore_list), {'six': 6, 'five': 5, 'four': 4, 'three': 3, 'two': 2})
+        lines2 = ["Words are flowing out like endless rain into a paper cup. They slither wildly as they slip away across the universe. Pools of sorrow, waves of joy are drifting through my opened mind. Possessing and caressing me. Images of broken light which dance before me like a million eyes. They call me on and on across the universe. Thoughts meander like a restless wind inside a letterbox they. They tumble blindly as they make their way across the universe. Jai guru deva, om. Sounds of laughter shades of life are ringing. Through my open ears inciting and inviting meLimitless undying love which shines around me like a million suns. It calls me on and on across the universe"]
+        self.assertEqual(extract_keyword(lines2,ignore_list),{'they': 6, 'me': 5, 'like': 4, 'universe': 4, 'are': 3})
+
+class Week06SpellCheck(UTestCase):
+    def test_SpellControl(self):
+        from cp.ex06.spell_check import spell_check
+        corrections = {'occurence': 'occurrence', 'apsolute': 'absolute', 'teh': 'the', 'acess': 'access', 'occured': 'occurred', 'exampel': 'example'}
+        text = "The apsolute acess to teh data occured in this exampel"
+        self.assertEqual(spell_check(text, corrections),"The absolute access to the data occurred in this example")
+        text2= "The first occurence of teh mean apsolute error formula look at teh exampel below"
+        self.assertEqual(spell_check(text2, corrections),"The first occurrence of the mean absolute error formula look at the example below")
+        self.assertEqual(spell_check("We can handle teh damag", {'damag': 'damage'}),"We can handle teh damage")
+        self.assertEqual(spell_check("We can handle teh damag.",{'damag': 'damage'}),"We can handle teh damage.")
+        text3 = "The apsolute acess to teh, data occured in this exampel."
+        self.assertEqual(spell_check(text3, corrections),"The absolute access to the, data occurred in this example.")
+        
+class Week06GetPeopleByLanguage(UTestCase):
+    def test_GetPeopleByLanguage(self):
+        from cp.ex06.language import get_people_by_language
+        name_languages = {
+                'Peter': ['Danish', 'English', 'German'],
+                'Alice': ['English', 'French', 'Spanish'],
+                'John': ['Spanish', 'English', 'French'],
+                'Maria': ['Danish', 'Spanish', 'German'],
+                'Anna': ['German', 'English', 'French'],
+                'David': ['English', 'French'],
+                'Sophia': ['Danish', 'Spanish'],
+                'Michael': ['German', 'English'],
+                'Emma': ['English', 'French'],
+                'Daniel': ['Spanish', 'English', 'German'],
+                'Laura': ['English', 'Spanish', 'Italian'],
+                'Mark': ['English', 'German'],
+                'Isabella': ['French', 'Spanish'],
+                'William': ['English'],
+                'Sophie': ['German', 'French'],
+                'Robert': ['English', 'German'],
+                'Olivia': ['French', 'Spanish'],
+                'James': ['English'],
+                'Ella': ['Spanish', 'Italian'],
+                'Alexander': ['English', 'German'],
+                'Lily': ['English', 'French']
+                }
+        self.assertEqual(get_people_by_language('English', name_languages),['Peter', 'Alice', 'John', 'Anna', 'David', 'Michael', 'Emma', 'Daniel', 'Laura', 'Mark', 'William', 'Robert', 'James', 'Alexander', 'Lily'])
+        self.assertEqual(get_people_by_language('Spanish', name_languages),['Alice', 'John', 'Maria', 'Sophia', 'Daniel', 'Laura', 'Isabella', 'Olivia', 'Ella'])
+        self.assertEqual(get_people_by_language('German', name_languages),['Peter', 'Maria', 'Anna', 'Michael', 'Daniel', 'Mark', 'Sophie', 'Robert', 'Alexander'])
+        self.assertEqual(get_people_by_language('French', name_languages),['Alice', 'John', 'Anna', 'David', 'Emma', 'Isabella', 'Sophie', 'Olivia', 'Lily'])
+
+class Week06TruncateAndNormalize(UTestCase):
+    def test_truncate(self):
+        from cp.ex06.truncate import truncate_values
+        settings = {'vmin': 0, 'vmax': 2, 'normalize': False}
+        settings2 = {'vmin': 0, 'vmax': 2, 'normalize': True}
+        float_list = [0.5,0.4,-0.3, 1.5, 2.5, 3.5]
+        float_list2 = [0,1.,2.,3.,4.,5.]        
+        self.assertEqual((truncate_values(float_list,settings)),[0.5, 0.4, 0, 1.5, 2, 2])
+        self.assertEqual((truncate_values(float_list2,settings2)),[0.0, 0.2, 0.4, 0.6, 0.8, 1.0])
+
+
+class Week06SentimentAnalysis(UTestCase):
+    def test_sentiment_analysis(self):
+        from cp.ex06.sentiment_analysis import sentiment_analysis
+        self.assertEqual(sentiment_analysis('I think the food was excellent and great, but the waiter service was horrible '),-5)
+        self.assertEqual(sentiment_analysis('When I woke up, I was feeling very bad, but then I had a coffee, and my day turned out to be excellent '),4)
+        self.assertEqual(sentiment_analysis('I know it is good not to complain, but the selection criteria were genuinely inadequate and unfair '),-1)
+
+
+class Week06MultiTap(UTestCase):
+    def test_multi_tap(self):
+        from cp.ex06.multi_tap import multi_tap 
+        self.assertEqual(multi_tap([7, 7, 7, 7, 6, 6, 6], [0, 0.7, 0.8, 0.9, 1, 1.1, 1.2]), 'PRO')
+        self.assertEqual(multi_tap([4, 4, 4, 0, 2, 6, 0, 4, 4, 2, 7, 7, 9, 9, 9], [0.1, 0.3, 0.6, 1.0, 1.2, 1.4, 1.7, 2.0, 2.2, 2.5, 2.9, 3.9, 4.3, 4.4, 4.8]), "I AM HAPPY")
+        self.assertEqual(multi_tap([7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 8, 8, 3], [0.1, 0.5, 0.8, 1.2, 2.6, 3.7, 4.1, 4.2, 4.5, 4.9, 5.1, 5.4, 5.6, 5.9]), "SPROUD")
+        self.assertEqual(multi_tap([4, 4, 4, 2, 2, 2, 3, 3, 0, 4, 4, 4, 2, 2, 2, 3, 3, 0, 2, 2, 2, 2, 2, 9, 9, 9], [0.3, 0.7, 0.8, 1.1, 1.3, 1.5, 1.7, 1.8, 2.1, 2.4, 2.7, 3.0, 3.4, 3.7, 3.9, 4.0, 4.3, 4.5, 4.7, 5.0, 6.4, 7.9, 8.3, 8.5, 8.7, 9.0]), "ICE ICE BABY")
+        self.assertEqual(multi_tap([5, 5, 5, 4, 4, 4, 8, 8, 8, 3, 3, 0, 5, 5, 5, 2, 8, 8, 4, 4, 4, 0, 5, 5, 5, 4, 4, 4, 7, 7, 7, 7, 8], [0.7, 0.9, 1.2, 1.6, 1.7, 2.0, 2.4, 2.5, 2.8, 3.2, 3.5, 3.7, 3.9, 4.3, 4.6, 4.8, 5.0, 5.3, 5.6, 6.3, 6.7, 6.8, 7.1, 7.3, 7.5, 7.8, 8.0, 8.1, 8.3, 8.5, 8.7, 8.9, 9.3]), "LIVE LAUGH LIST")
+        
+
+class Week06Tests(Report): #240 total.
+    title = "Tests for week 06"
+    #version = 0.1
+    #url = "https://gitlab.compute.dtu.dk/cp/02002students/-/blob/master/cp/tests"
+    pack_imports = [cp]
+    individual_imports = []
+    questions = [
+                (Week06TextToNato, 10),
+                (Week06LetterHistogram, 10),
+                (Week06WordHistogram, 10),
+                (Week06ExtractKeywords, 10),
+                (Week06SpellCheck, 10),
+                (Week06GetPeopleByLanguage, 10),
+                (Week06TruncateAndNormalize, 10),
+                (Week06SentimentAnalysis,10),
+                (Week06MultiTap, 10),
+                ]
+
+if __name__ == '__main__':
+    from unitgrade import evaluate_report_student
+    evaluate_report_student(Week06Tests())
diff --git a/cp/tests/unitgrade_data/Week06ExtractKeywords.pkl b/cp/tests/unitgrade_data/Week06ExtractKeywords.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..68a7243852f77012525a4006f8214294de57c4cd
Binary files /dev/null and b/cp/tests/unitgrade_data/Week06ExtractKeywords.pkl differ
diff --git a/cp/tests/unitgrade_data/Week06GetPeopleByLanguage.pkl b/cp/tests/unitgrade_data/Week06GetPeopleByLanguage.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..910f5dcc642db901c1998a4fe9b42ed10949fd69
Binary files /dev/null and b/cp/tests/unitgrade_data/Week06GetPeopleByLanguage.pkl differ
diff --git a/cp/tests/unitgrade_data/Week06LetterHistogram.pkl b/cp/tests/unitgrade_data/Week06LetterHistogram.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..2a7019b2f58629e083e892a7b9b6d162316be1a8
Binary files /dev/null and b/cp/tests/unitgrade_data/Week06LetterHistogram.pkl differ
diff --git a/cp/tests/unitgrade_data/Week06MultiTap.pkl b/cp/tests/unitgrade_data/Week06MultiTap.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..9e47cc3bcb9612d0a03f2ab900cffbeeba344858
Binary files /dev/null and b/cp/tests/unitgrade_data/Week06MultiTap.pkl differ
diff --git a/cp/tests/unitgrade_data/Week06SentimentAnalysis.pkl b/cp/tests/unitgrade_data/Week06SentimentAnalysis.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..0ef765ada2bb5a6d7847cd8322cb3b992c568ee2
Binary files /dev/null and b/cp/tests/unitgrade_data/Week06SentimentAnalysis.pkl differ
diff --git a/cp/tests/unitgrade_data/Week06SpellCheck.pkl b/cp/tests/unitgrade_data/Week06SpellCheck.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..726072d5c7f2f78db8eb35792fd57052262dda43
Binary files /dev/null and b/cp/tests/unitgrade_data/Week06SpellCheck.pkl differ
diff --git a/cp/tests/unitgrade_data/Week06TextToNato.pkl b/cp/tests/unitgrade_data/Week06TextToNato.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..a63fe7a60b77202564e2b6ccc495d748805a1246
Binary files /dev/null and b/cp/tests/unitgrade_data/Week06TextToNato.pkl differ
diff --git a/cp/tests/unitgrade_data/Week06TruncateAndNormalize.pkl b/cp/tests/unitgrade_data/Week06TruncateAndNormalize.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..bf549de170e56e1cc06aa565a927d5f40c2f5061
Binary files /dev/null and b/cp/tests/unitgrade_data/Week06TruncateAndNormalize.pkl differ
diff --git a/cp/tests/unitgrade_data/Week06WordHistogram.pkl b/cp/tests/unitgrade_data/Week06WordHistogram.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..581377a19dea24072306e1ed742d5211aec25947
Binary files /dev/null and b/cp/tests/unitgrade_data/Week06WordHistogram.pkl differ
diff --git a/cp/utils/__init__.py b/cp/utils/__init__.py
index 7de222064c9f80c98edd660d314614a5a86828ab..c9bf24e54d475806d511254e677f9f48d430f544 100644
--- a/cp/utils/__init__.py
+++ b/cp/utils/__init__.py
@@ -1 +1 @@
-"""This subpackage is empty. We can use it for general utility files at a later point (or remove it)."""
+"""DO NOT EDIT/ADD TO THIS FILE."""