diff --git a/cpp/src/helper.h b/cpp/src/helper.h
index 684a72e..b49013e 100644
--- a/cpp/src/helper.h
+++ b/cpp/src/helper.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <vector>
 
 std::string trim(std::string s);
 
diff --git a/solutions/cpp/solution1/CMakeLists.txt b/solutions/cpp/solution1/CMakeLists.txt
new file mode 100644
index 0000000..4be08d0
--- /dev/null
+++ b/solutions/cpp/solution1/CMakeLists.txt
@@ -0,0 +1,68 @@
+cmake_minimum_required(VERSION 3.14)
+
+set(CMAKE_CXX_STANDARD 11)
+
+project(youtube)
+
+include(FetchContent)
+FetchContent_Declare(
+  googletest
+  # Specify the commit you depend on and update it regularly.
+  URL https://github.com/google/googletest/archive/53495a2a7d6ba7e0691a7f3602e9a5324bba6e45.zip
+)
+
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
+include(GoogleTest)
+
+if(MSVC)
+  add_compile_options(/Wall)
+else()
+  add_compile_options(
+      -Wall
+      -Wextra
+      -pedantic
+      # Below is to avoid unnecessary warnings before code is implemented.
+      -Wno-unused-parameter)
+endif()
+
+file(COPY src/videos.txt DESTINATION src/)
+
+add_library(youtube_lib
+    src/commandparser.cpp
+    src/commandparser.h
+    src/helper.cpp
+    src/helper.h
+    src/video.cpp
+    src/video.h
+    src/videolibrary.cpp
+    src/videolibrary.h
+    src/videoplayer.cpp
+    src/videoplayer.h
+    src/videoplaylist.h
+    src/videoplaylist.cpp)
+
+add_executable(youtube src/main.cpp)
+target_link_libraries(youtube youtube_lib)
+
+enable_testing()
+
+add_executable(part1_test test/part1_test.cpp)
+target_link_libraries(part1_test youtube_lib gmock gtest gtest_main)
+gtest_discover_tests(part1_test)
+
+add_executable(part2_test test/part2_test.cpp)
+target_link_libraries(part2_test youtube_lib gmock gtest gtest_main)
+gtest_discover_tests(part2_test)
+
+add_executable(part3_test test/part3_test.cpp)
+target_link_libraries(part3_test youtube_lib gmock gtest gtest_main)
+gtest_discover_tests(part3_test)
+
+add_executable(part4_test test/part4_test.cpp)
+target_link_libraries(part4_test youtube_lib gmock gtest gtest_main)
+gtest_discover_tests(part4_test)
+
+add_executable(videolibrary_test test/videolibrary_test.cpp)
+target_link_libraries(videolibrary_test youtube_lib gmock gtest gtest_main)
+gtest_discover_tests(videolibrary_test)
diff --git a/solutions/cpp/solution1/README.md b/solutions/cpp/solution1/README.md
new file mode 100644
index 0000000..f4b24b5
--- /dev/null
+++ b/solutions/cpp/solution1/README.md
@@ -0,0 +1,97 @@
+# YouTube Challenge - C++
+
+The C++ YouTube Challenge uses C++ 11, CMake and [GTest](https://google.github.io/googletest/).
+
+NOTE: **Please do not edit videos.txt as it will cause tests to break. There is no need to modify this file to complete this challenge.**
+
+## Installing C++ and CMake
+You need to install:
+
+- [CMake 3.14+](https://cmake.org/install/) and a build tool like GNU make or Ninja.
+- A compiler that supports C++ 11 or higher ([clang](https://clang.llvm.org/get_started.html), gcc/g++, MSVC).
+
+On Debian-based Linux distributions you can install the dependencies with this
+command:
+
+```shell
+sudo apt install cmake make clang
+```
+
+On Windows, you can install the [Microsoft Visual Studio Community
+Edition](https://visualstudio.microsoft.com/downloads/) for the compiler and
+build tools. Make sure to choose to install CMake as part of this.
+
+On a Mac, you need to go to the App Store and download Xcode for free - it is Apple's IDE - Integrated Development Environment. Without Xcode, you will have no compiler (i.e. clang or gcc or g++) and no build tools, (i.e. make).
+After you've installed Xcode you need to install command line tools:
+
+```shell
+xcode-select --install
+```
+
+For CMake: 
+
+- Download the latest CMake Mac binary distribution here: https://cmake.org/download/.
+
+- Double click the downloaded .dmg file to install it. In the window that pops up, drag the CMake icon into the Application folder.
+
+- Add this line to your .bashrc file: PATH="/Applications/CMake.app/Contents/bin":"$PATH"
+
+- Reload your .bashrc file: source ~/.bashrc
+
+- Verify the latest cmake version is installed: cmake --version
+
+> Note: You can use a higher version of C++ (C++ 17 or C++ 20) if you want:
+> Just change the `CMAKE_CXX_STANDARD` in `CMakeLists.txt`!
+
+## Setting up
+
+You can write code in the editor or IDE of your choice. However, different
+editors have different ways of dealing with C++ code, so in case of doubt we
+recommend you run the code and tests from the command line as shown below.
+
+The below commands assume you are located in the `cpp/` folder of the git
+repository.
+
+## Running and Testing from the Command line
+
+To build:
+
+```shell script
+cmake -S . -B build
+```
+
+Followed by:
+
+```shell script
+cmake --build build/
+```
+
+To run:
+
+```shell script
+./build/youtube
+```
+
+To run all the tests:
+
+```shell script
+ctest --test-dir build --output-on-failure
+```
+
+To run tests for a single Part (after building):
+
+```shell script
+./build/part1_test
+./build/part2_test
+./build/part3_test
+./build/part4_test
+```
+
+To run a subset of the tests, in this example, all tests of part 1 that contain
+`showAllVideos` in their name:
+
+```shell script
+./build/part1_test --gtest_filter='*showAllVideos*'
+```
+
+> NOTE: Don't forget to rebuild your code ater making changes for testing.
diff --git a/solutions/cpp/solution1/src/commandparser.cpp b/solutions/cpp/solution1/src/commandparser.cpp
new file mode 100644
index 0000000..4e079e1
--- /dev/null
+++ b/solutions/cpp/solution1/src/commandparser.cpp
@@ -0,0 +1,158 @@
+#include "commandparser.h"
+
+#include <iostream>
+#include <sstream>
+#include <utility>
+#include <vector>
+
+CommandParser::CommandParser(VideoPlayer&& vp) : mVideoPlayer(std::move(vp)) {}
+
+void CommandParser::executeCommand(const std::vector<std::string>& command) {
+  if (command.empty()) {
+    std::cout << "No commands passed in to executeCommand, that is unexpected"
+              << std::endl;
+    return;
+  }
+
+  if (command[0] == "NUMBER_OF_VIDEOS") {
+    mVideoPlayer.numberOfVideos();
+  } else if (command[0] == "SHOW_ALL_VIDEOS") {
+    mVideoPlayer.showAllVideos();
+  } else if (command[0] == "PLAY") {
+    if (command.size() != 2) {
+      std::cout << "Please enter PLAY command followed by video_id."
+                << std::endl;
+    } else {
+      mVideoPlayer.playVideo(command[1]);
+    }
+  } else if (command[0] == "PLAY_RANDOM") {
+    mVideoPlayer.playRandomVideo();
+  } else if (command[0] == "STOP") {
+    mVideoPlayer.stopVideo();
+  } else if (command[0] == "PAUSE") {
+    mVideoPlayer.pauseVideo();
+  } else if (command[0] == "CONTINUE") {
+    mVideoPlayer.continueVideo();
+  } else if (command[0] == "SHOW_PLAYING") {
+    mVideoPlayer.showPlaying();
+  } else if (command[0] == "CREATE_PLAYLIST") {
+    if (command.size() != 2) {
+      std::cout << "Please enter CREATE_PLAYLIST command followed by video_id."
+                << std::endl;
+    } else {
+      mVideoPlayer.createPlaylist(command[1]);
+    }
+  } else if (command[0] == "ADD_TO_PLAYLIST") {
+    if (command.size() != 3) {
+      std::cout << "Please enter ADD_TO_PLAYLIST command followed by playlist "
+                   "name and video_id."
+                << std::endl;
+    } else {
+      mVideoPlayer.addVideoToPlaylist(command[1], command[2]);
+    }
+  } else if (command[0] == "REMOVE_FROM_PLAYLIST") {
+    if (command.size() != 3) {
+      std::cout << "Please enter REMOVE_FROM_PLAYLIST command followed by "
+                   "playlist name and video_id."
+                << std::endl;
+    } else {
+      mVideoPlayer.removeFromPlaylist(command[1], command[2]);
+    }
+  } else if (command[0] == "CLEAR_PLAYLIST") {
+    if (command.size() != 2) {
+      std::cout
+          << "Please enter CLEAR_PLAYLIST command followed by a playlist name."
+          << std::endl;
+    } else {
+      mVideoPlayer.clearPlaylist(command[1]);
+    }
+  } else if (command[0] == "DELETE_PLAYLIST") {
+    if (command.size() != 2) {
+      std::cout
+          << "Please enter DELETE_PLAYLIST command followed by a playlist name."
+          << std::endl;
+    } else {
+      mVideoPlayer.deletePlaylist(command[1]);
+    }
+  } else if (command[0] == "SHOW_PLAYLIST") {
+    if (command.size() != 2) {
+      std::cout
+          << "Please enter SHOW_PLAYLIST command followed by a playlist name."
+          << std::endl;
+    } else {
+      mVideoPlayer.showPlaylist(command[1]);
+    }
+  } else if (command[0] == "SHOW_ALL_PLAYLISTS") {
+    mVideoPlayer.showAllPlaylists();
+  } else if (command[0] == "SEARCH_VIDEOS") {
+    if (command.size() != 2) {
+      std::cout
+          << "Please enter SEARCH_VIDEOS command followed by a search term."
+          << std::endl;
+    } else {
+      mVideoPlayer.searchVideos(command[1]);
+    }
+  } else if (command[0] == "SEARCH_VIDEOS_WITH_TAG") {
+    if (command.size() != 2) {
+      std::cout << "Please enter SEARCH_VIDEOS_WITH_TAG command followed by a "
+                   "video tag."
+                << std::endl;
+    } else {
+      mVideoPlayer.searchVideosWithTag(command[1]);
+    }
+  } else if (command[0] == "FLAG_VIDEO") {
+    switch (command.size()) {
+      case 2:
+        mVideoPlayer.flagVideo(command[1]);
+        break;
+      case 3:
+        mVideoPlayer.flagVideo(command[1], command[2]);
+        break;
+      default:
+        std::cout << "Please enter FLAG_VIDEO command followed by a video_id "
+                     "and an optional flag reason."
+                  << std::endl;
+    }
+  } else if (command[0] == "ALLOW_VIDEO") {
+    if (command.size() != 2) {
+      std::cout << "Please enter ALLOW_VIDEO command followed by a video_id."
+                << std::endl;
+    } else {
+      mVideoPlayer.allowVideo(command[1]);
+    }
+  } else if (command[0] == "HELP") {
+    getHelp();
+  } else {
+    std::cout << "Please enter a valid command, type HELP for a list of "
+                 "available commands."
+              << std::endl;
+  }
+}
+
+void CommandParser::getHelp() const {
+  static const char* const helpText = R"(
+Available commands:
+    NUMBER_OF_VIDEOS - Shows how many videos are in the library.
+    SHOW_ALL_VIDEOS - Lists all videos from the library.
+    PLAY <video_id> - Plays specified video.
+    PLAY_RANDOM - Plays a random video from the library.
+    STOP - Stop the current video.
+    PAUSE - Pause the current video.
+    CONTINUE - Resume the current paused video.
+    SHOW_PLAYING - Displays the title, url and paused status of the video that is currently playing (or paused).
+    CREATE_PLAYLIST <playlist_name> - Creates a new (empty) playlist with the provided name.
+    ADD_TO_PLAYLIST <playlist_name> <video_id> - Adds the requested video to the playlist.
+    REMOVE_FROM_PLAYLIST <playlist_name> <video_id> - Removes the specified video from the specified playlist
+    CLEAR_PLAYLIST <playlist_name> - Removes all the videos from the playlist.
+    DELETE_PLAYLIST <playlist_name> - Deletes the playlist.
+    SHOW_PLAYLIST <playlist_name> - List all the videos in this playlist.
+    SHOW_ALL_PLAYLISTS - Display all the available playlists.
+    SEARCH_VIDEOS <search_term> - Display all the videos whose titles contain the search_term.
+    SEARCH_VIDEOS_WITH_TAG <tag_name> -Display all videos whose tags contains the provided tag.
+    FLAG_VIDEO <video_id> <flag_reason> - Mark a video as flagged.
+    ALLOW_VIDEO <video_id> - Removes a flag from a video.
+    HELP - Displays help.
+    EXIT - Terminates the program execution.
+)";
+  std::cout << helpText << std::endl;
+}
diff --git a/solutions/cpp/solution1/src/commandparser.h b/solutions/cpp/solution1/src/commandparser.h
new file mode 100644
index 0000000..3016d66
--- /dev/null
+++ b/solutions/cpp/solution1/src/commandparser.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "videoplayer.h"
+
+/**
+ * A class used to parse and execute a user Command.
+ */
+class CommandParser {
+ private:
+  VideoPlayer mVideoPlayer;
+
+  void getHelp() const;
+
+ public:
+  CommandParser(VideoPlayer&& vp);
+
+  // This class is not copyable to avoid expensive copies.
+  CommandParser(const CommandParser&) = delete;
+  CommandParser& operator=(const CommandParser&) = delete;
+
+  // This class is movable.
+  CommandParser(CommandParser&&) = default;
+  CommandParser& operator=(CommandParser&&) = default;
+
+  // Executes the given user command.
+  void executeCommand(const std::vector<std::string>& command);
+};
diff --git a/solutions/cpp/solution1/src/helper.cpp b/solutions/cpp/solution1/src/helper.cpp
new file mode 100644
index 0000000..cf93f9e
--- /dev/null
+++ b/solutions/cpp/solution1/src/helper.cpp
@@ -0,0 +1,48 @@
+#include "helper.h"
+
+#include <iostream>
+#include <sstream>
+#include <vector>
+
+std::string trim(std::string toTrim) {
+  size_t trimPos = toTrim.find_first_not_of(" \t");
+  toTrim.erase(0, trimPos);
+  trimPos = toTrim.find_last_not_of(" \t");
+  if (std::string::npos != trimPos) {
+    toTrim.erase(trimPos + 1);
+  }
+  return toTrim;
+}
+
+std::vector<std::string> splitlines(std::string output) {
+  std::vector<std::string> commandOutput;
+  std::stringstream ss(output);
+  std::string line;
+  while (std::getline(ss, line, '\n')) {
+    commandOutput.emplace_back(line);
+  }
+  return commandOutput;
+}
+
+std::string toLower(const std::string& str) {
+  std::string output;
+  for (const auto& ch : str) {
+    output += (char)(tolower(ch));
+  }
+  return output;
+}
+
+bool contains(const std::string& s1, const std::string& s2) {
+  std::string s1_lower = toLower(s1);
+  std::string s2_lower = toLower(s2);
+  return s1_lower.find(s2_lower) != std::string::npos;
+}
+
+bool isNumber(const std::string& str) {
+  for (const char ch : str) {
+    if (!isdigit(ch)) {
+      return false;
+    }
+  }
+  return true;
+}
diff --git a/solutions/cpp/solution1/src/helper.h b/solutions/cpp/solution1/src/helper.h
new file mode 100644
index 0000000..0db382d
--- /dev/null
+++ b/solutions/cpp/solution1/src/helper.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+// Removes spaces and tabs from start and end string.
+std::string trim(std::string s);
+
+// Splits string at newlines into a vector of string.
+std::vector<std::string> splitlines(std::string output);
+
+// Converts a string to lowercase.
+std::string toLower(const std::string& str);
+
+// Checks if string s1 contains string s2.
+bool contains(const std::string& s1, const std::string& s2);
+
+// Checks if a string can be converted into a valid number.
+// This is done by checking that each character in string is a digit.
+bool isNumber(const std::string& str);
\ No newline at end of file
diff --git a/solutions/cpp/solution1/src/main.cpp b/solutions/cpp/solution1/src/main.cpp
new file mode 100644
index 0000000..2de3781
--- /dev/null
+++ b/solutions/cpp/solution1/src/main.cpp
@@ -0,0 +1,53 @@
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "commandparser.h"
+#include "helper.h"
+#include "videolibrary.h"
+#include "videoplayer.h"
+
+int main() {
+  std::cout << "Hello and welcome to YouTube, what would you like to do? "
+               "Enter HELP for list of available commands or EXIT to terminate."
+            << std::endl;
+
+  std::string userInput;
+  std::string command;
+  std::vector<std::string> commandList;
+  VideoPlayer vp;
+  CommandParser cp = CommandParser(std::move(vp));
+
+  for (;;) {
+    std::cout << "YT> ";
+    if (!std::getline(std::cin, userInput)) {
+      break;
+    }
+    if (userInput.empty()) {
+      std::cout << "Please enter a valid command, type HELP for a list of "
+                   "available commands."
+                << std::endl;
+    } else {
+      std::stringstream test(userInput);
+      while (std::getline(test, command, ' ')) {
+        command = trim(command);
+        commandList.push_back(command);
+      }
+      std::transform(commandList[0].begin(), commandList[0].end(),
+                     commandList[0].begin(),
+                     [](char c) { return static_cast<char>(std::toupper(c)); });
+      if (commandList[0] == "EXIT") {
+        break;
+      }
+      cp.executeCommand(commandList);
+      commandList.clear();
+    }
+  }
+  std::cout
+      << "YouTube has now terminated it's execution. Thank you and goodbye!"
+      << std::endl;
+}
diff --git a/solutions/cpp/solution1/src/video.cpp b/solutions/cpp/solution1/src/video.cpp
new file mode 100644
index 0000000..c28ec58
--- /dev/null
+++ b/solutions/cpp/solution1/src/video.cpp
@@ -0,0 +1,27 @@
+#include "video.h"
+
+#include <iostream>
+#include <utility>
+#include <vector>
+
+Video::Video(std::string&& title, std::string&& videoId,
+             std::vector<std::string>&& tags) :
+  mTitle(std::move(title)),
+  mVideoId(std::move(videoId)),
+  mTags(std::move(tags)) {
+}
+
+const std::string& Video::getTitle() const { return mTitle; }
+
+const std::string& Video::getVideoId() const { return mVideoId; }
+
+const std::vector<std::string>& Video::getTags() const { return mTags; }
+
+const std::string Video::getTagsAsStr() const {
+    std::string tag_str = "";
+    for (const auto& tag : mTags) {
+        tag_str = tag_str + tag + " ";
+    }
+    tag_str = tag_str.substr(0, tag_str.size() - 1);
+    return tag_str;
+}
diff --git a/solutions/cpp/solution1/src/video.h b/solutions/cpp/solution1/src/video.h
new file mode 100644
index 0000000..dd1a8f7
--- /dev/null
+++ b/solutions/cpp/solution1/src/video.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+/**
+ * A class used to represent a video.
+ */
+class Video {
+ private:
+  std::string mTitle;
+  std::string mVideoId;
+  std::vector<std::string> mTags;
+
+ public:
+  Video(std::string&& title, std::string&& videoId,
+        std::vector<std::string>&& tags);
+
+  // Returns the title of the video.
+  const std::string& getTitle() const;
+
+  // Returns the video id of the video.
+  const std::string& getVideoId() const;
+
+  // Returns a readonly collection of the tags of the video.
+  const std::vector<std::string>& getTags() const;
+
+  // Returns the tags of video joined as a string separated by spaces.
+  const std::string getTagsAsStr() const;
+};
diff --git a/solutions/cpp/solution1/src/videolibrary.cpp b/solutions/cpp/solution1/src/videolibrary.cpp
new file mode 100644
index 0000000..0136762
--- /dev/null
+++ b/solutions/cpp/solution1/src/videolibrary.cpp
@@ -0,0 +1,148 @@
+#include "videolibrary.h"
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "helper.h"
+#include "video.h"
+
+VideoLibrary::VideoLibrary() {
+  std::ifstream file("./src/videos.txt");
+  if (file.is_open()) {
+    std::string line;
+    while (std::getline(file, line)) {
+      std::stringstream linestream(line);
+      std::string title;
+      std::string id;
+      std::string tag;
+      std::vector<std::string> tags;
+      std::getline(linestream, title, '|');
+      std::getline(linestream, id, '|');
+      while (std::getline(linestream, tag, ',')) {
+        tags.emplace_back(trim(std::move(tag)));
+      }
+      Video video = Video(trim(std::move(title)), trim(id), std::move(tags));
+      mVideos.emplace(trim(std::move(id)), std::move(video));
+    }
+  } else {
+    std::cout << "Couldn't find videos.txt" << std::endl;
+  }
+}
+
+std::vector<Video> VideoLibrary::getVideos() const {
+  std::vector<Video> result;
+  for (const auto& video : mVideos) {
+    result.emplace_back(video.second);
+  }
+  return result;
+}
+
+const Video* VideoLibrary::getVideo(const std::string& videoId) const {
+  const auto found = mVideos.find(videoId);
+  if (found == mVideos.end()) {
+    return nullptr;
+  } else {
+    return &(found->second);
+  }
+}
+
+void VideoLibrary::addNewPlaylist(const std::string& playlistName) const {
+  std::string id = toLower(playlistName);
+  if (getPlaylist(id) != nullptr) {
+    return;
+  }
+  std::string title = playlistName;
+  std::vector<std::string> videoIds;
+  VideoPlaylist playlist = VideoPlaylist(
+    std::move(title), std::move(videoIds));
+  mPlaylists.emplace(trim(std::move(id)), std::move(playlist));
+}
+
+void VideoLibrary::addVideoToPlaylist(
+  const std::string& playlistName, const std::string& videoId) const {
+  std::string id = toLower(playlistName);
+  const VideoPlaylist* playlist = getPlaylist(id);
+  if (playlist == nullptr) {
+    return;
+  }
+  playlist->addVideo(videoId);
+  mPlaylists.emplace(trim(std::move(id)), std::move(*playlist));
+}
+
+void VideoLibrary::removeVideoFromPlaylist(
+  const std::string& playlistName, const std::string& videoId) const {
+  std::string id = toLower(playlistName);
+  const VideoPlaylist* playlist = getPlaylist(id);
+  if (playlist == nullptr) {
+    return;
+  }
+  playlist->removeVideo(videoId);
+  mPlaylists.emplace(trim(std::move(id)), std::move(*playlist));
+}
+
+void VideoLibrary::clearPlaylist(const std::string& playlistName) const {
+  std::string id = toLower(playlistName);
+  const VideoPlaylist* playlist = getPlaylist(id);
+  if (playlist == nullptr) {
+    return;
+  }
+  playlist->clear();
+  mPlaylists.emplace(trim(std::move(id)), std::move(*playlist));
+}
+
+void VideoLibrary::deletePlaylist(const std::string& playlistName) const {
+  std::string id = toLower(playlistName);
+  const VideoPlaylist* playlist = getPlaylist(id);
+  if (playlist == nullptr) {
+    return;
+  }
+  mPlaylists.erase(id);
+}
+
+std::vector<VideoPlaylist> VideoLibrary::getPlaylists() const {
+  std::vector<VideoPlaylist> result;
+  for (const auto& playlist : mPlaylists) {
+    result.emplace_back(playlist.second);
+  }
+  return result;
+}
+
+const VideoPlaylist* VideoLibrary::getPlaylist(const std::string& playlistName) const {
+  std::string id = toLower(playlistName);
+  const auto found = mPlaylists.find(id);
+  if (found == mPlaylists.end()) {
+    return nullptr;
+  } else {
+    return &(found->second);
+  }
+}
+
+bool VideoLibrary::isFlagged(const std::string& id) const {
+  const auto found = mFlagged.find(id);
+  if (found == mFlagged.end()) {
+    return false;
+  }
+  return true;
+}
+
+void VideoLibrary::setFlagged(
+  const std::string& id, const std::string& reason) const {
+  mFlagged.emplace(trim(std::move(id)), std::move(reason));
+}
+
+void VideoLibrary::unsetFlagged(const std::string& id) const {
+  mFlagged.erase(id);
+};
+
+const std::string VideoLibrary::getFlaggedReason(
+  const std::string& id) const {
+  const auto found = mFlagged.find(id);
+  if (found == mFlagged.end()) {
+    return "";
+  }
+  return found->second;
+}
diff --git a/solutions/cpp/solution1/src/videolibrary.h b/solutions/cpp/solution1/src/videolibrary.h
new file mode 100644
index 0000000..1d64c9a
--- /dev/null
+++ b/solutions/cpp/solution1/src/videolibrary.h
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "video.h"
+#include "videoplaylist.h"
+
+/**
+ * A class used to represent a Video Library.
+ */
+class VideoLibrary {
+ private:
+  // Map of available video <id, Video object>.
+  std::unordered_map<std::string, Video> mVideos;
+  // Map of available playlists <id, Playlist object>
+  // Note, playlist id = playlist name in lowercase.
+  mutable std::unordered_map<std::string, VideoPlaylist> mPlaylists;
+  // Map of flagged video ids <video id, reason due to which video is flagged>.
+  mutable std::unordered_map<std::string, std::string> mFlagged;
+
+ public:
+  VideoLibrary();
+
+  // This class is not copyable to avoid expensive copies.
+  VideoLibrary(const VideoLibrary&) = delete;
+  VideoLibrary& operator=(const VideoLibrary&) = delete;
+
+  // This class is movable.
+  VideoLibrary(VideoLibrary&&) = default;
+  VideoLibrary& operator=(VideoLibrary&&) = default;
+
+  // Returns a vector of all available videos.
+  std::vector<Video> getVideos() const;
+
+  // Returns a specific video corresponding to the input videoId
+  // if found, else nullptr.
+  const Video *getVideo(const std::string& videoId) const;
+
+  // Returns list of all playlists in the library.
+  std::vector<VideoPlaylist> getPlaylists() const;
+
+  // Returns a specific playlist corresponding to the input name if found,
+  // else nullptr.
+  const VideoPlaylist* getPlaylist(const std::string& playlistName) const;
+
+  // Creates and adds a new playlist to video library.
+  void addNewPlaylist(const std::string& playlistName) const;
+
+  // Adds a video to a playlist.
+  void addVideoToPlaylist(
+    const std::string& playlistName, const std::string& videoId) const;
+
+  // Removes a video from a playlist.
+  void removeVideoFromPlaylist(
+    const std::string& playlistName, const std::string& videoId) const;
+
+  // Removes all videos from a playlist.
+  void clearPlaylist(const std::string& playlistName) const;
+
+  // Deletes a playlist from video library.
+  void deletePlaylist(const std::string& playlistName) const;
+
+  // Checks if video corresponding to a id is flagged in the library.
+  bool isFlagged(const std::string& id) const;
+
+  // Sets a video as flagged in the video library.
+  void setFlagged(const std::string& id, const std::string& reason) const;
+
+  // Unflags a video in video library.
+  void unsetFlagged(const std::string& id) const;
+
+  // Returns the reason associated with a video being flagged.
+  const std::string getFlaggedReason(const std::string& id) const;
+};
diff --git a/solutions/cpp/solution1/src/videoplayer.cpp b/solutions/cpp/solution1/src/videoplayer.cpp
new file mode 100644
index 0000000..01b64d0
--- /dev/null
+++ b/solutions/cpp/solution1/src/videoplayer.cpp
@@ -0,0 +1,475 @@
+#include "videoplayer.h"
+
+#include "video.h"
+#include "videoplaylist.h"
+#include "helper.h"
+
+#include <iostream>
+
+// A custom sort function to sort video objects using title.
+bool SortByTitle(Video v1, Video v2) {
+ // if str1.compare(str2) < 0 => str1 comes before str2 lexicographically.
+ return v1.getTitle().compare(v2.getTitle()) < 0;
+}
+
+void VideoPlayer::numberOfVideos() {
+  std::cout << mVideoLibrary.getVideos().size() << " videos in the library"
+            << std::endl;
+}
+
+void VideoPlayer::showAllVideos() {
+  std::cout << "Here's a list of all available videos:" << std::endl;
+  // Get all available videos.
+  auto videos = mVideoLibrary.getVideos();
+  // Sort videos by title.
+  std::sort(videos.begin(), videos.end(), SortByTitle);
+  // Iterate over all videos and display the title, id and tags.
+  // If the video is flagged, display the reason of being flagged as well.
+  for (const auto& video : videos) {
+    std::cout << video.getTitle() << " ";
+    std::cout << "(" << video.getVideoId() << ") ";
+    std::cout << "[" << video.getTagsAsStr() << "]";
+    if (mVideoLibrary.isFlagged(video.getVideoId())){
+      std::cout << " - FLAGGED (reason: ";
+      std::cout << mVideoLibrary.getFlaggedReason(video.getVideoId()) << ")";
+    }
+    std::cout << std::endl;
+  }
+}
+
+void VideoPlayer::playVideo(const std::string& videoId) {
+  // Get the video using video id.
+  const auto* video = mVideoLibrary.getVideo(videoId);
+  // If video is nullptr, it denotes that no such video exists.
+  if (video == nullptr) {
+    std::cout << "Cannot play video: Video does not exist" << std::endl;
+    return;
+  }
+  // If video is flagged, display that flagged video cannot be played.
+  if (mVideoLibrary.isFlagged(video->getVideoId())) {
+    std::cout << "Cannot play video: Video is currently flagged (reason: " ;
+    std::cout << mVideoLibrary.getFlaggedReason(video->getVideoId()) <<")" << std::endl;
+    return;
+  }
+  // If any video is already playing, stop it before playing the new video.
+  if (!playingId.empty()) {
+    stopVideo();
+  }
+  // Set the playingId to video id and play the video.
+  playingId = video->getVideoId();
+  // pausedId is emptied since no video is paused once we play a new video.
+  pausedId = "";
+  std::cout << "Playing video: " << video->getTitle() << std::endl;
+}
+
+void VideoPlayer::stopVideo() {
+  // If playingId is empty, then no video is playing and
+  // there is nothing to stop.
+  if (playingId.empty()) {
+    std::cout << "Cannot stop video: No video is currently playing" << std::endl;
+    return;
+  }
+  // Get the video object which is currently playing using playingId.
+  const auto& video = mVideoLibrary.getVideo(playingId);
+  // Empty the playingId and stop the video.
+  playingId = "";
+  std::cout << "Stopping video: " << video->getTitle() << std::endl;
+}
+
+void VideoPlayer::playRandomVideo() {
+  // Get all available videos.
+  const auto& videos = mVideoLibrary.getVideos();
+
+  // Obtain all unflagged videos since we cannot play a flagged video.
+  std::vector<Video> unflagged_videos;
+  for (const auto& video : videos) {
+    if (mVideoLibrary.isFlagged(video.getVideoId())) {
+      continue;
+    }
+    unflagged_videos.push_back(video);
+  }
+
+  // If there are no unflagged videos, display appropriate message.
+  if (unflagged_videos.empty()) {
+    std::cout << "No videos available" << std::endl;
+    return;
+  }
+  
+  // Choose a random integer and restrict it between
+  // [0, size of unflagged videos - 1].
+  // rand() returns a random integer.
+  // Dividing it with unflagged_videos.size() returns a
+  // remainder which will be between
+  // [0, size of unflagged videos - 1].
+  // So, modulus % operator is used here to get the remainder.
+  const auto& index = rand() % unflagged_videos.size();
+  // Use the chosen integer as the index of random video to be played.
+  playVideo(unflagged_videos[index].getVideoId());
+}
+
+void VideoPlayer::pauseVideo() {
+  // If playingId is empty, then no video is playing and
+  // there is nothing to be paused.
+  if (playingId.empty()) {
+    std::cout << "Cannot pause video: No video is currently playing" << std::endl;
+    return;
+  }
+  // If pausedId is not empty, then the video is already paused.
+  if (!pausedId.empty()) {
+    std::cout << "Video already paused: ";
+    std::cout << mVideoLibrary.getVideo(pausedId)->getTitle() << std::endl;
+    return;
+  }
+  // Copy playingId to pausedId since the currently playing video
+  // will be paused.
+  pausedId = playingId;
+  std::cout << "Pausing video: ";
+  std::cout << mVideoLibrary.getVideo(pausedId)->getTitle() << std::endl;
+
+}
+
+void VideoPlayer::continueVideo() {
+  // If playingId is empty, then no video is playing and
+  // there is nothing to be continued.
+  if (playingId.empty()) {
+    std::cout << "Cannot continue video: No video is currently playing" << std::endl;
+    return;
+  }
+  // If playingId is empty, then no video is paused and
+  // there is nothing to be continued.
+  if (pausedId.empty()) {
+    std::cout << "Cannot continue video: Video is not paused" << std::endl;
+    return;
+  }
+  // Clear the pausedId since video is played now.
+  pausedId = "";
+  std::cout << "Continuing video: ";
+  std::cout << mVideoLibrary.getVideo(playingId)->getTitle() << std::endl;
+}
+
+void VideoPlayer::showPlaying() {
+  // If playingId is empty, then no video is playing and
+  // there is nothing to be shown.
+  if (playingId.empty()) {
+    std::cout << "No video is currently playing" << std::endl;
+    return;
+  }
+  // Get the video currently playing using playingId.
+  const auto& video = mVideoLibrary.getVideo(playingId);
+  std::cout << "Currently playing: " << video->getTitle() << " ";
+  std::cout << "(" << video->getVideoId() << ") ";
+  std::cout << "[" << video->getTagsAsStr() << "]";
+  // If pausedId is not empty, display the information
+  // that video is paused.
+  if (!pausedId.empty()) {
+    std::cout << " - PAUSED" << std::endl;
+  } else {
+    std::cout << std::endl;
+  }
+}
+
+void VideoPlayer::createPlaylist(const std::string& playlistName) {
+  // Get the playlist with the input playlistName.
+  const VideoPlaylist* playlist = mVideoLibrary.getPlaylist(playlistName);
+  // If the returned playlist is not nullptr, a playlist with the
+  // input name already exists and a new one cannot be created.
+  if (playlist != nullptr) {
+    std::cout << "Cannot create playlist: ";
+    std::cout << "A playlist with the same name already exists" << std::endl;
+    return;
+  }
+  mVideoLibrary.addNewPlaylist(playlistName);
+  std::cout << "Successfully created new playlist: " << playlistName << std::endl;
+}
+
+void VideoPlayer::addVideoToPlaylist(const std::string& playlistName,
+                                     const std::string& videoId) {
+  // Get the playlist with the input playlistName.
+  const VideoPlaylist* playlist = mVideoLibrary.getPlaylist(playlistName);
+  // If returned playlist is nullptr, then no playlist with the name exists
+  // and a video cannot be added.
+  if (playlist == nullptr) {
+    std::cout << "Cannot add video to " << playlistName;
+    std::cout << ": Playlist does not exist" << std::endl;
+    return;
+  }
+
+  // Get the video with the input videoId.
+  const Video* video = mVideoLibrary.getVideo(videoId);
+  // If returned video is nullptr, then no such video exists and
+  // cannot be added to playlist.
+  if (video == nullptr) {
+    std::cout << "Cannot add video to " << playlistName;
+    std::cout << ": Video does not exist" << std::endl;
+    return;
+  }
+
+  // Flagged video cannot be added to a playlist.
+  if (mVideoLibrary.isFlagged(video->getVideoId())) {
+    std::cout << "Cannot add video to " << playlistName;
+    std::cout << ": Video is currently flagged (reason: " ;
+    std::cout << mVideoLibrary.getFlaggedReason(video->getVideoId()) <<")" << std::endl;
+    return;
+  }
+
+  // A video already present in playlist cannot be added again.
+  if (playlist->hasVideo(videoId)) {
+    std::cout << "Cannot add video to " << playlistName;
+    std::cout << ": Video already added" << std::endl;
+    return;
+  }
+
+  mVideoLibrary.addVideoToPlaylist(playlistName, videoId);
+  std::cout << "Added video to " << playlistName << ": ";
+  std::cout << video->getTitle() << std::endl;
+}
+
+void VideoPlayer::showAllPlaylists() {
+  // Fetch all playlists and iterate over thme to display the names.
+  const auto& playlists = mVideoLibrary.getPlaylists();
+  if (!playlists.size()) {
+    std::cout << "No playlists exist yet" << std::endl;
+    return;
+  }
+  std::cout << "Showing all playlists:" << std::endl;
+  for (const auto& playlist : playlists) {
+    std::cout << playlist.getTitle() << std::endl;
+  }
+}
+
+void VideoPlayer::showPlaylist(const std::string& playlistName) {
+  // Fetch the playlist using the input playlistName.
+  const VideoPlaylist* playlist = mVideoLibrary.getPlaylist(playlistName);
+  // If returned playlist is nullptr, then no such playlist exists.
+  if (playlist == nullptr) {
+    std::cout << "Cannot show playlist " << playlistName;
+    std::cout << ": Playlist does not exist" << std::endl;
+    return;
+  }
+  std::cout << "Showing playlist: " << playlistName << std::endl;
+
+  // Obtain all videos in the playlist and iterate over them to
+  // display video info.
+  const auto& videoIds = playlist->getVideoIds();
+  if (videoIds.empty()) {
+    std::cout << "No videos here yet" << std::endl;
+    return;
+  }
+  for (const auto& videoId : videoIds) {
+    const Video* video = mVideoLibrary.getVideo(videoId);
+    std::cout << video->getTitle() << " ";
+    std::cout << "(" << video->getVideoId() << ") ";
+    std::cout << "[" << video->getTagsAsStr() << "]";
+    if (mVideoLibrary.isFlagged(video->getVideoId())){
+      std::cout << " - FLAGGED (reason: ";
+      std::cout << mVideoLibrary.getFlaggedReason(video->getVideoId()) << ")";
+    }
+    std::cout << std::endl;
+  }
+}
+
+void VideoPlayer::removeFromPlaylist(const std::string& playlistName,
+                                     const std::string& videoId) {
+  // Get the playlist with the input playlistName.
+  const VideoPlaylist* playlist = mVideoLibrary.getPlaylist(playlistName);
+  // If returned playlist is nullptr, then no playlist with the name exists
+  // and a video cannot be removed.
+  if (playlist == nullptr) {
+    std::cout << "Cannot remove video from " << playlistName;
+    std::cout << ": Playlist does not exist" << std::endl;
+    return;
+  }
+
+  // Get the video with the input videoId.
+  const Video* video = mVideoLibrary.getVideo(videoId);
+  // If returned video is nullptr, then no such video exists and
+  // cannot be added to playlist.
+  if (video == nullptr) {
+    std::cout << "Cannot remove video from " << playlistName;
+    std::cout << ": Video does not exist" << std::endl;
+    return;
+  }
+
+  // If video is not present in playlist, it cannot be removed.
+  if (!playlist->hasVideo(videoId)) {
+    std::cout << "Cannot remove video from " << playlistName;
+    std::cout << ": Video is not in playlist" << std::endl;
+    return;
+  }
+
+  mVideoLibrary.removeVideoFromPlaylist(playlistName, videoId);
+  std::cout << "Removed video from " << playlistName << ": ";
+  std::cout << video->getTitle() << std::endl;
+}
+
+void VideoPlayer::clearPlaylist(const std::string& playlistName) {
+  // Get the playlist with the input playlistName.
+  const VideoPlaylist* playlist = mVideoLibrary.getPlaylist(playlistName);
+  // If returned playlist is nullptr, then no playlist with the name exists
+  // and cannot be cleared.
+  if (playlist == nullptr) {
+    std::cout << "Cannot clear playlist " << playlistName;
+    std::cout << ": Playlist does not exist" << std::endl;
+    return;
+  }
+  mVideoLibrary.clearPlaylist(playlistName);
+  std::cout << "Successfully removed all videos from " << playlistName << std::endl;
+}
+
+void VideoPlayer::deletePlaylist(const std::string& playlistName) {
+  // Get the playlist with the input playlistName.
+  const VideoPlaylist* playlist = mVideoLibrary.getPlaylist(playlistName);
+  // If returned playlist is nullptr, then no playlist with the name exists
+  // and cannot be deleted.
+  if (playlist == nullptr) {
+    std::cout << "Cannot delete playlist " << playlistName;
+    std::cout << ": Playlist does not exist" << std::endl;
+    return;
+  }
+  mVideoLibrary.deletePlaylist(playlistName);
+  std::cout << "Deleted playlist: " << playlistName << std::endl; 
+}
+
+void VideoPlayer::searchVideos(const std::string& searchTerm) {
+  // Get list of all available videos.
+  const auto& videos = mVideoLibrary.getVideos();
+  std::vector<Video> matches;
+  // Iterate over videos and skip the flagged ones.
+  // If the search term is present in video title,
+  // add it to a new vector.
+  for (const auto& video : videos) {
+    if (mVideoLibrary.isFlagged(video.getVideoId())){
+      continue;
+    }
+    if (contains(video.getTitle(), searchTerm)) {
+      matches.push_back(video);
+    }
+  }
+  if (matches.empty()) {
+    std::cout << "No search results for " << searchTerm << std::endl;
+    return;
+  }
+
+  const int num_results = matches.size();
+  std::cout << "Here are the results for " << searchTerm << ":" << std::endl;
+  sort(matches.begin(), matches.end(), SortByTitle);
+  for (int i = 1; i <= num_results; i++) {
+    std::cout << i << ") ";
+    const auto& video = matches[i - 1];
+    std::cout << video.getTitle() << " ";
+    std::cout << "(" << video.getVideoId() << ") ";
+    std::cout << "[" << video.getTagsAsStr() << "]" << std::endl;
+  }
+  std::cout << "Would you like to play any of the above? ";
+  std::cout << "If yes, specify the number of the video." << std::endl;
+  std::cout << "If your answer is not a valid number, we will assume it's a no." << std::endl;
+
+  std::string input;
+  std::cin >> input;
+
+  if (!isNumber(input)) {
+    return;
+  }
+  // Converts a string to integer.
+  // Note that, if string is not a valid number, this will
+  // result in an exception.
+  int position = std::stoi(input);
+  if (position > num_results || position < 1) {
+    return;
+  }
+  playVideo(matches[position - 1].getVideoId());
+}
+
+void VideoPlayer::searchVideosWithTag(const std::string& videoTag) {
+  // Get list of all available videos.
+  const auto& videos = mVideoLibrary.getVideos();
+  std::vector<Video> matches;
+  // Iterate over videos and skip the flagged ones.
+  // If the search term is present in video tags,
+  // add it to a new vector.
+  for (const auto& video : videos) {
+    if (mVideoLibrary.isFlagged(video.getVideoId())){
+      continue;
+    }
+    if (contains(video.getTagsAsStr(), videoTag)) {
+      matches.push_back(video);
+    }
+  }
+  if (matches.empty()) {
+    std::cout << "No search results for " << videoTag << std::endl;
+    return;
+  }
+
+  const int num_results = matches.size();
+  std::cout << "Here are the results for " << videoTag << ":" << std::endl;
+  sort(matches.begin(), matches.end(), SortByTitle);
+  for (int i = 1; i <= num_results; i++) {
+    std::cout << i << ") ";
+    const auto& video = matches[i - 1];
+    std::cout << video.getTitle() << " ";
+    std::cout << "(" << video.getVideoId() << ") ";
+    std::cout << "[" << video.getTagsAsStr() << "]" << std::endl;
+  }
+  std::cout << "Would you like to play any of the above? ";
+  std::cout << "If yes, specify the number of the video." << std::endl;
+  std::cout << "If your answer is not a valid number, we will assume it's a no." << std::endl;
+
+  std::string input;
+  std::cin >> input;
+
+  if (!isNumber(input)) {
+    return;
+  }
+  // Converts a string to integer.
+  // Note that, if string is not a valid number, this will
+  // result in an exception.
+  int position = std::stoi(input);
+  if (position > num_results || position < 1) {
+    return;
+  }
+  playVideo(matches[position - 1].getVideoId());
+}
+
+void VideoPlayer::flagVideo(const std::string& videoId) {
+  flagVideo(videoId, "Not supplied");
+}
+
+void VideoPlayer::flagVideo(const std::string& videoId, const std::string& reason) {
+  // Get the video using video id.
+  const auto* video = mVideoLibrary.getVideo(videoId);
+  // If video is nullptr, it denotes that no such video exists.
+  if (video == nullptr) {
+  std::cout << "Cannot flag video: Video does not exist" << std::endl;
+  return;
+  }
+  // A video which is already flagged, cannot be flagged again.
+  if (mVideoLibrary.isFlagged(videoId)) {
+  std::cout << "Cannot flag video: Video is already flagged" << std::endl;
+  return;
+  }
+  // If the currently playing video is the one requested to be flagged,
+  // stop the video first.
+  if (videoId == playingId) {
+  stopVideo();
+  }
+  mVideoLibrary.setFlagged(videoId, reason);
+  std::cout << "Successfully flagged video: "<< video->getTitle();
+  std::cout << " (reason: " << reason << ")" << std::endl;
+}
+
+void VideoPlayer::allowVideo(const std::string& videoId) {
+  // Get the video using video id.
+  const auto* video = mVideoLibrary.getVideo(videoId);
+  // If video is nullptr, it denotes that no such video exists.
+  if (video == nullptr) {
+  std::cout << "Cannot remove flag from video: Video does not exist" << std::endl;
+  return;
+  }
+  // If the video is not flagged already, it cannot be unflagged.
+  if (!mVideoLibrary.isFlagged(videoId)) {
+  std::cout << "Cannot remove flag from video: Video is not flagged" << std::endl;
+  return;
+  }
+  mVideoLibrary.unsetFlagged(videoId);
+  std::cout << "Successfully removed flag from video: "<< video->getTitle() << std::endl;
+}
diff --git a/solutions/cpp/solution1/src/videoplayer.h b/solutions/cpp/solution1/src/videoplayer.h
new file mode 100644
index 0000000..b811b37
--- /dev/null
+++ b/solutions/cpp/solution1/src/videoplayer.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <string>
+
+#include "videolibrary.h"
+
+/**
+ * A class used to represent a Video Player.
+ */
+class VideoPlayer {
+ private:
+  VideoLibrary mVideoLibrary;
+  std::string playingId;
+  std::string pausedId;
+
+ public:
+  VideoPlayer() = default;
+
+  // This class is not copyable to avoid expensive copies.
+  VideoPlayer(const VideoPlayer&) = delete;
+  VideoPlayer& operator=(const VideoPlayer&) = delete;
+
+  // This class is movable.
+  VideoPlayer(VideoPlayer&&) = default;
+  VideoPlayer& operator=(VideoPlayer&&) = default;
+
+  void numberOfVideos();
+  void showAllVideos();
+  void playVideo(const std::string& videoId);
+  void stopVideo();
+  void playRandomVideo();
+  void pauseVideo();
+  void continueVideo();
+  void showPlaying();
+  void createPlaylist(const std::string& playlistName);
+  void addVideoToPlaylist(const std::string& playlistName, const std::string& videoId);
+  void showAllPlaylists();
+  void showPlaylist(const std::string& playlistName);
+  void removeFromPlaylist(const std::string& playlistName, const std::string& videoId);
+  void clearPlaylist(const std::string& playlistName);
+  void deletePlaylist(const std::string& playlistName);
+  void searchVideos(const std::string& searchTerm);
+  void searchVideosWithTag(const std::string& videoTag);
+  void flagVideo(const std::string& videoId);
+  void flagVideo(const std::string& videoId, const std::string& reason);
+  void allowVideo(const std::string& videoId);
+};
diff --git a/solutions/cpp/solution1/src/videoplaylist.cpp b/solutions/cpp/solution1/src/videoplaylist.cpp
new file mode 100644
index 0000000..29f2e96
--- /dev/null
+++ b/solutions/cpp/solution1/src/videoplaylist.cpp
@@ -0,0 +1,37 @@
+#include "video.h"
+
+#include "videoplaylist.h"
+
+#include <iostream>
+#include <utility>
+#include <vector>
+
+VideoPlaylist::VideoPlaylist(
+    std::string&& title, std::vector<std::string>&& videoIds) :
+  mTitle(std::move(title)),
+  mVideoIds(std::move(videoIds)) {
+}
+
+const std::string& VideoPlaylist::getTitle() const { return mTitle; }
+
+const std::vector<std::string>& VideoPlaylist::getVideoIds() const {
+    return mVideoIds;
+}
+
+bool VideoPlaylist::hasVideo(const std::string& videoId) const {
+   auto it = std::find(this->mVideoIds.begin(), this->mVideoIds.end(), videoId);
+   return it != this->mVideoIds.end(); 
+}
+
+void VideoPlaylist::addVideo(const std::string& videoId) const {
+    this->mVideoIds.push_back(videoId);
+}
+
+void VideoPlaylist::removeVideo(const std::string& videoId) const {
+    auto it = std::find(mVideoIds.begin(), mVideoIds.end(), videoId);
+    this->mVideoIds.erase(it);
+}
+
+void VideoPlaylist::clear() const {
+    this->mVideoIds.clear();
+}
diff --git a/solutions/cpp/solution1/src/videoplaylist.h b/solutions/cpp/solution1/src/videoplaylist.h
new file mode 100644
index 0000000..e49b9c6
--- /dev/null
+++ b/solutions/cpp/solution1/src/videoplaylist.h
@@ -0,0 +1,32 @@
+#pragma once
+
+/** A class used to represent a Playlist */
+
+class VideoPlaylist {
+ private:
+  std::string mTitle;
+  mutable std::vector<std::string> mVideoIds;
+
+ public:
+  VideoPlaylist(
+  	std::string&& title, std::vector<std::string>&& videoIds);
+
+  // Returns the title of the playlist.
+  const std::string& getTitle() const;
+
+  // Returns the video ids in the playlist.
+  const std::vector<std::string>& getVideoIds() const;
+
+  // Checks if a video is present in a playlist.
+  bool hasVideo(const std::string& videoId) const;
+
+  // Adds a new video id to playlist.
+  void addVideo(const std::string& videoId) const;
+
+  // Removes a video id from a playlist.
+  void removeVideo(const std::string& videoId) const;
+
+  // Clears the playlist.
+  void clear() const;
+};
+
diff --git a/solutions/cpp/solution1/src/videos.txt b/solutions/cpp/solution1/src/videos.txt
new file mode 100644
index 0000000..0800bb7
--- /dev/null
+++ b/solutions/cpp/solution1/src/videos.txt
@@ -0,0 +1,5 @@
+Funny Dogs | funny_dogs_video_id |  #dog , #animal
+Amazing Cats | amazing_cats_video_id |  #cat , #animal
+Another Cat Video | another_cat_video_id |  #cat , #animal
+Life at Google | life_at_google_video_id |  #google , #career
+Video about nothing | nothing_video_id |
\ No newline at end of file
diff --git a/solutions/cpp/solution1/test/part1_test.cpp b/solutions/cpp/solution1/test/part1_test.cpp
new file mode 100644
index 0000000..d50f60e
--- /dev/null
+++ b/solutions/cpp/solution1/test/part1_test.cpp
@@ -0,0 +1,282 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "../src/videoplayer.h"
+#include "../src/helper.h"
+
+using ::testing::ContainsRegex;
+using ::testing::HasSubstr;
+
+TEST(Part1, numberOfVideos) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.numberOfVideos();
+  std::string output = testing::internal::GetCapturedStdout();
+  EXPECT_THAT(output, HasSubstr("5 videos in the library"));
+}
+
+TEST(Part1, showAllVideos) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.showAllVideos();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 6);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Here's a list of all available videos:"));
+  EXPECT_THAT(commandOutput[1],
+              HasSubstr("Amazing Cats (amazing_cats_video_id) [#cat #animal]"));
+  EXPECT_THAT(
+      commandOutput[2],
+      HasSubstr("Another Cat Video (another_cat_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[3],
+              HasSubstr("Funny Dogs (funny_dogs_video_id) [#dog #animal]"));
+  EXPECT_THAT(
+      commandOutput[4],
+      HasSubstr("Life at Google (life_at_google_video_id) [#google #career]"));
+  EXPECT_THAT(commandOutput[5], HasSubstr("Video about nothing (nothing_video_id) []"));
+}
+
+TEST(Part1, playVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+}
+
+TEST(Part1, playVideoNonExistent) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("some_other_video_that_doesnt_exist");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Cannot play video: Video does not exist"));
+}
+
+TEST(Part1, playVideoStopPrevious) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.playVideo("funny_dogs_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 3);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Stopping video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("Playing video: Funny Dogs"));
+}
+
+TEST(Part1, playVideoDontStopPreviousIfNonExistent) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.playVideo("some_other_video");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 2);
+  EXPECT_THAT(commandOutput[0], Not(HasSubstr("Stopping video: Amazing Cats")));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Cannot play video: Video does not exist"));
+}
+
+TEST(Part1, stopVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.stopVideo();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 2);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Stopping video: Amazing Cats"));
+}
+
+TEST(Part1, stopVideoTwice) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.stopVideo();
+  videoPlayer.stopVideo();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 3);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Stopping video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[2],
+              HasSubstr("Cannot stop video: No video is currently playing"));
+}
+
+TEST(Part1, stopVideoNothingPlaying) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.stopVideo();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Cannot stop video: No video is currently playing"));
+}
+
+TEST(Part1, playRandomVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playRandomVideo();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(
+      commandOutput[0],
+      ContainsRegex("Playing video: (Amazing Cats|Another Cat Video|Funny "
+                    "Dogs|Life at Google|Video about nothing)"));
+}
+
+TEST(Part1, playRandomVideoStopsPreviousVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.playRandomVideo();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 3);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Stopping video: Amazing Cats"));
+  EXPECT_THAT(
+      commandOutput[2],
+      ContainsRegex("Playing video: (Amazing Cats|Another Cat Video|Funny "
+                    "Dogs|Life at Google|Video about nothing)"));
+}
+
+TEST(Part1, showPlaying) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.showPlaying();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 2);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Currently playing: Amazing Cats "
+                                "(amazing_cats_video_id) [#cat #animal]"));
+}
+
+TEST(Part1, showNothingPlaying) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.showPlaying();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(commandOutput[0], HasSubstr("No video is currently playing"));
+}
+
+TEST(Part1, pauseVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.pauseVideo();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 2);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Pausing video: Amazing Cats"));
+}
+
+TEST(Part1, pauseVideoShowVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.pauseVideo();
+  videoPlayer.showPlaying();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 3);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Pausing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[2],
+              HasSubstr("Currently playing: Amazing Cats "
+                        "(amazing_cats_video_id) [#cat #animal] - PAUSED"));
+}
+
+TEST(Part1, pauseVideoPlayVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.pauseVideo();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.showPlaying();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 5);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Pausing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("Stopping video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[4],
+              HasSubstr("Currently playing: Amazing Cats "
+                        "(amazing_cats_video_id) [#cat #animal]"));
+  EXPECT_THAT(output, Not(HasSubstr("PAUSED")));
+}
+
+TEST(Part1, pauseAlreadyPausedVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.pauseVideo();
+  videoPlayer.pauseVideo();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 3);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Pausing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("Video already paused: Amazing Cats"));
+}
+
+TEST(Part1, pauseVideoNothingPlaying) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.pauseVideo();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Cannot pause video: No video is currently playing"));
+}
+
+TEST(Part1, continueVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.pauseVideo();
+  videoPlayer.continueVideo();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 3);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Pausing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("Continuing video: Amazing Cats"));
+}
+
+TEST(Part1, continueVideoNotPaused) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.continueVideo();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 2);
+  EXPECT_THAT(commandOutput[1], HasSubstr("Cannot continue video: Video is not paused"));
+}
+
+TEST(Part1, continueVideoNothingPlaying) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.continueVideo();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr("Cannot continue video: No video is currently playing"));
+}
diff --git a/solutions/cpp/solution1/test/part2_test.cpp b/solutions/cpp/solution1/test/part2_test.cpp
new file mode 100644
index 0000000..7206f4a
--- /dev/null
+++ b/solutions/cpp/solution1/test/part2_test.cpp
@@ -0,0 +1,304 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "../src/videoplayer.h"
+#include "../src/helper.h"
+
+using ::testing::HasSubstr;
+using ::testing::MatchesRegex;
+
+TEST(Part2, createPlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Successfully created new playlist: mY_plaYList"));
+}
+
+TEST(Part2, createExistingPlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  videoPlayer.createPlaylist("MY_PLAYLIST");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 2);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Successfully created new playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Cannot create playlist: A playlist with the "
+                                "same name already exists"));
+}
+
+TEST(Part2, addToPlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  videoPlayer.addVideoToPlaylist("mY_playLIST", "amazing_cats_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 2);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Successfully created new playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Added video to mY_playLIST: Amazing Cats"));
+}
+
+TEST(Part2, addToPlaylistAlreadyAdded) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  videoPlayer.addVideoToPlaylist("mY_plaYList", "amazing_cats_video_id");
+  videoPlayer.addVideoToPlaylist("mY_plaYList", "amazing_cats_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 3);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Successfully created new playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Added video to mY_plaYList: Amazing Cats"));
+  EXPECT_THAT(
+      commandOutput[2],
+      HasSubstr("Cannot add video to mY_plaYList: Video already added"));
+}
+
+TEST(Part2, addVideoToPlaylistNonExistentVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  videoPlayer.addVideoToPlaylist("mY_plaYList", "amazing_cats_video_id");
+  videoPlayer.addVideoToPlaylist("mY_plaYList", "some_other_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 3);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Successfully created new playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Added video to mY_plaYList: Amazing Cats"));
+  EXPECT_THAT(
+      commandOutput[2],
+      HasSubstr("Cannot add video to mY_plaYList: Video does not exist"));
+}
+
+TEST(Part2, addVideoToPlaylistNonExistent) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.addVideoToPlaylist("anotHER_playlist", "amazing_cats_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr(
+          "Cannot add video to anotHER_playlist: Playlist does not exist"));
+}
+
+TEST(Part2, addVideoToPlaylistNonExistentNoPlaylistNoVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.addVideoToPlaylist("anotHER_playlist", "video_does_not_exist");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr(
+          "Cannot add video to anotHER_playlist: Playlist does not exist"));
+}
+
+TEST(Part2, showAllPlaylistsNoPlaylistsExist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.showAllPlaylists();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(commandOutput[0], HasSubstr("No playlists exist yet"));
+}
+
+TEST(Part2, showAllPlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  videoPlayer.createPlaylist("anotHER_playlist");
+  videoPlayer.showAllPlaylists();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 5);
+  EXPECT_THAT(commandOutput[2], HasSubstr("Showing all playlists:"));
+  EXPECT_THAT(commandOutput[4], HasSubstr("mY_plaYList"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("anotHER_playlist"));
+}
+
+TEST(Part2, showPlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  videoPlayer.showPlaylist("mY_plaYList");
+  videoPlayer.addVideoToPlaylist("mY_plaYList", "amazing_cats_video_id");
+  videoPlayer.showPlaylist("mY_plaYList");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 6);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Successfully created new playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Showing playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("No videos here yet"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Added video to mY_plaYList: Amazing Cats"));
+  EXPECT_THAT(commandOutput[4], HasSubstr("Showing playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[5],
+              HasSubstr("Amazing Cats (amazing_cats_video_id) [#cat #animal]"));
+}
+
+TEST(Part2, showPlaylistAfterRemoveAVideoFromPlaylistThenReAdd) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  videoPlayer.addVideoToPlaylist("mY_plaYList", "amazing_cats_video_id");
+  videoPlayer.addVideoToPlaylist("mY_plaYList", "life_at_google_video_id");
+  videoPlayer.removeFromPlaylist("mY_plaYList", "amazing_cats_video_id");
+  videoPlayer.addVideoToPlaylist("mY_plaYList", "amazing_cats_video_id");
+  videoPlayer.showPlaylist("mY_plaYList");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 8);
+  EXPECT_THAT(commandOutput[5], HasSubstr("Showing playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[6],
+              HasSubstr("Life at Google (life_at_google_video_id) [#google #career]"));
+  EXPECT_THAT(commandOutput[7],
+              HasSubstr("Amazing Cats (amazing_cats_video_id) [#cat #animal]"));
+}
+
+TEST(Part2, showPlaylistNonExistent) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.showPlaylist("mY_plaYList");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr("Cannot show playlist mY_plaYList: Playlist does not exist"));
+}
+
+TEST(Part2, removeFromPlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  videoPlayer.addVideoToPlaylist("mY_plaYList", "amazing_cats_video_id");
+  videoPlayer.removeFromPlaylist("MY_playlist", "amazing_cats_video_id");
+  videoPlayer.removeFromPlaylist("mY_plaYList", "amazing_cats_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 4);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Successfully created new playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Added video to mY_plaYList: Amazing Cats"));
+  EXPECT_THAT(commandOutput[2],
+              HasSubstr("Removed video from MY_playlist: Amazing Cats"));
+  EXPECT_THAT(
+      commandOutput[3],
+      HasSubstr(
+          "Cannot remove video from mY_plaYList: Video is not in playlist"));
+}
+
+TEST(Part2, removeFromPlaylistVideoNotInPlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  videoPlayer.removeFromPlaylist("mY_plaYList", "amazing_cats_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 2);
+  EXPECT_THAT(
+      commandOutput[1],
+      HasSubstr(
+          "Cannot remove video from mY_plaYList: Video is not in playlist"));
+}
+
+TEST(Part2, removeFromPlaylistNonexistentVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  videoPlayer.addVideoToPlaylist("mY_plaYList", "amazing_cats_video_id");
+  videoPlayer.removeFromPlaylist("mY_plaYList", "some_other_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 3);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Successfully created new playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Added video to mY_plaYList: Amazing Cats"));
+  EXPECT_THAT(
+      commandOutput[2],
+      HasSubstr("Cannot remove video from mY_plaYList: Video does not exist"));
+}
+
+TEST(Part2, removeFromPlaylistNonexistentPlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.removeFromPlaylist("my_cool_playlist", "some_other_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Cannot remove video from my_cool_playlist: "
+                                "Playlist does not exist"));
+}
+
+TEST(Part2, clearPlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  videoPlayer.addVideoToPlaylist("mY_plaYList", "amazing_cats_video_id");
+  videoPlayer.showPlaylist("mY_plaYList");
+  videoPlayer.clearPlaylist("mY_plaYList");
+  videoPlayer.showPlaylist("mY_plaYList");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 7);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Successfully created new playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Added video to mY_plaYList: Amazing Cats"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("Showing playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[3],
+              HasSubstr("Amazing Cats (amazing_cats_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[4],
+              HasSubstr("Successfully removed all videos from mY_plaYList"));
+  EXPECT_THAT(commandOutput[5], HasSubstr("Showing playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[6], HasSubstr("No videos here yet"));
+}
+
+TEST(Part2, clearPlaylistNonexistent) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.clearPlaylist("mY_plaYList");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr("Cannot clear playlist mY_plaYList: Playlist does not exist"));
+}
+
+TEST(Part2, deletePlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("mY_plaYList");
+  videoPlayer.deletePlaylist("MY_PLAYLIST");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 2);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Successfully created new playlist: mY_plaYList"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Deleted playlist: MY_PLAYLIST"));
+}
+
+TEST(Part2, deletePlaylistNonexistent) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.deletePlaylist("mY_plaYList");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr("Cannot delete playlist mY_plaYList: Playlist does not exist"));
+}
diff --git a/solutions/cpp/solution1/test/part3_test.cpp b/solutions/cpp/solution1/test/part3_test.cpp
new file mode 100644
index 0000000..6f306eb
--- /dev/null
+++ b/solutions/cpp/solution1/test/part3_test.cpp
@@ -0,0 +1,189 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "../src/videoplayer.h"
+#include "../src/helper.h"
+
+using ::testing::HasSubstr;
+using ::testing::MatchesRegex;
+
+TEST(Part3, searchVideosWithNoAnswer) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  std::streambuf* orig = std::cin.rdbuf();
+  std::istringstream input("No");
+  std::cin.rdbuf(input.rdbuf());
+  videoPlayer.searchVideos("cat");
+  std::cin.rdbuf(orig);
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 5);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Here are the results for cat:"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("1) Amazing Cats (amazing_cats_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("2) Another Cat Video (another_cat_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Would you like to play any of the above? If "
+                                "yes, specify the number of the video."));
+  EXPECT_THAT(
+      commandOutput[4],
+      HasSubstr(
+          "If your answer is not a valid number, we will assume it's a no."));
+  EXPECT_THAT(output, Not(HasSubstr("Playing video")));
+}
+
+TEST(Part3, searchVideosAndPlayAnswer) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  std::streambuf* orig = std::cin.rdbuf();
+  std::istringstream input("2");
+  std::cin.rdbuf(input.rdbuf());
+  videoPlayer.searchVideos("cat");
+  std::cin.rdbuf(orig);
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 6);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Here are the results for cat:"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("1) Amazing Cats (amazing_cats_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("2) Another Cat Video (another_cat_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Would you like to play any of the above? If "
+                                "yes, specify the number of the video."));
+  EXPECT_THAT(
+      commandOutput[4],
+      HasSubstr(
+          "If your answer is not a valid number, we will assume it's a no."));
+  EXPECT_THAT(commandOutput[5], HasSubstr("Playing video: Another Cat Video"));
+}
+
+TEST(Part3, searchVideosAnswerOutOfBounds) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  std::streambuf* orig = std::cin.rdbuf();
+  std::istringstream input("5");
+  std::cin.rdbuf(input.rdbuf());
+  videoPlayer.searchVideos("cat");
+  std::cin.rdbuf(orig);
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 5);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Here are the results for cat:"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("1) Amazing Cats (amazing_cats_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("2) Another Cat Video (another_cat_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Would you like to play any of the above? If "
+                                "yes, specify the number of the video."));
+  EXPECT_THAT(
+      commandOutput[4],
+      HasSubstr(
+          "If your answer is not a valid number, we will assume it's a no."));
+  EXPECT_THAT(output, Not(HasSubstr("Playing video")));
+}
+
+TEST(Part3, searchVideosInvalidNumber) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  std::streambuf* orig = std::cin.rdbuf();
+  std::istringstream input("ab3g");
+  std::cin.rdbuf(input.rdbuf());
+  videoPlayer.searchVideos("cat");
+  std::cin.rdbuf(orig);
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 5);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Here are the results for cat:"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("1) Amazing Cats (amazing_cats_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("2) Another Cat Video (another_cat_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Would you like to play any of the above? If "
+                                "yes, specify the number of the video."));
+  EXPECT_THAT(
+      commandOutput[4],
+      HasSubstr(
+          "If your answer is not a valid number, we will assume it's a no."));
+  EXPECT_THAT(output, Not(HasSubstr("Playing video")));
+}
+
+TEST(Part3, searchVideosNoResults) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.searchVideos("blah");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(commandOutput[0], HasSubstr("No search results for blah"));
+}
+
+TEST(Part3, searchVideosWithTagNoAnswer) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  std::streambuf* orig = std::cin.rdbuf();
+  std::istringstream input("no");
+  std::cin.rdbuf(input.rdbuf());
+  videoPlayer.searchVideosWithTag("#cat");
+  std::cin.rdbuf(orig);
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 5);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Here are the results for #cat:"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("1) Amazing Cats (amazing_cats_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("2) Another Cat Video (another_cat_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Would you like to play any of the above? If "
+                                "yes, specify the number of the video."));
+  EXPECT_THAT(
+      commandOutput[4],
+      HasSubstr(
+          "If your answer is not a valid number, we will assume it's a no."));
+  EXPECT_THAT(output, Not(HasSubstr("Playing video")));
+}
+
+TEST(Part3, searchVideosWithTagPlayAnswer) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  std::streambuf* orig = std::cin.rdbuf();
+  std::istringstream input("1");
+  std::cin.rdbuf(input.rdbuf());
+  videoPlayer.searchVideosWithTag("#cat");
+  std::cin.rdbuf(orig);
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 6);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Here are the results for #cat:"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("1) Amazing Cats (amazing_cats_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("2) Another Cat Video (another_cat_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Would you like to play any of the above? If "
+                                "yes, specify the number of the video."));
+  EXPECT_THAT(
+      commandOutput[4],
+      HasSubstr(
+          "If your answer is not a valid number, we will assume it's a no."));
+  EXPECT_THAT(commandOutput[5], HasSubstr("Playing video: Amazing Cats"));
+}
+
+TEST(Part3, searchVideosWithTagAnswerOutOfBounds) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  std::streambuf* orig = std::cin.rdbuf();
+  std::istringstream input("5");
+  std::cin.rdbuf(input.rdbuf());
+  videoPlayer.searchVideosWithTag("#cat");
+  std::cin.rdbuf(orig);
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 5);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Here are the results for #cat:"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("1) Amazing Cats (amazing_cats_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("2) Another Cat Video (another_cat_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Would you like to play any of the above? If "
+                                "yes, specify the number of the video."));
+  EXPECT_THAT(
+      commandOutput[4],
+      HasSubstr(
+          "If your answer is not a valid number, we will assume it's a no."));
+  EXPECT_THAT(output, Not(HasSubstr("Playing video")));
+}
+
+TEST(Part3, searchVideosWithTagNoResults) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.searchVideosWithTag("#blah");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(commandOutput[0], HasSubstr("No search results for #blah"));
+}
diff --git a/solutions/cpp/solution1/test/part4_test.cpp b/solutions/cpp/solution1/test/part4_test.cpp
new file mode 100644
index 0000000..08cc1ca
--- /dev/null
+++ b/solutions/cpp/solution1/test/part4_test.cpp
@@ -0,0 +1,353 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "../src/videoplayer.h"
+#include "../src/helper.h"
+
+using ::testing::HasSubstr;
+using ::testing::MatchesRegex;
+
+TEST(Part4, flagVideoWithReason) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.flagVideo("amazing_cats_video_id", "dont_like_cats");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: dont_like_cats)"));
+}
+
+TEST(Part4, flagVideoWithoutReason) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.flagVideo("another_cat_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  EXPECT_THAT(output, HasSubstr("Successfully flagged video: Another Cat Video "
+                                "(reason: Not supplied)"));
+}
+
+TEST(Part4, flagVideoAlreadyFlagged) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.flagVideo("amazing_cats_video_id", "dont_like_cats");
+  videoPlayer.flagVideo("amazing_cats_video_id", "dont_like_cats");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 2);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: dont_like_cats)"));
+  EXPECT_THAT(
+    commandOutput[1], HasSubstr("Cannot flag video: Video is already flagged"));
+}
+
+TEST(Part4, flagVideoNonexistent) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.flagVideo("video_does_not_exist", "flagVideo_reason");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(
+  commandOutput[0], HasSubstr("Cannot flag video: Video does not exist"));
+}
+
+TEST(Part4, flagVideoCanNoLongerPlay) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.flagVideo("amazing_cats_video_id");
+  videoPlayer.playVideo("amazing_cats_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 2);
+  EXPECT_THAT(
+  commandOutput[0],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: Not supplied)"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Cannot play video: Video is currently flagged "
+                                "(reason: Not supplied)"));
+}
+
+TEST(Part4, flagVideosPlayRandom) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.flagVideo("funny_dogs_video_id");
+  videoPlayer.flagVideo("amazing_cats_video_id");
+  videoPlayer.flagVideo("another_cat_video_id");
+  videoPlayer.flagVideo("life_at_google_video_id");
+  videoPlayer.flagVideo("nothing_video_id");
+  videoPlayer.playRandomVideo();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 6);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr(
+          "Successfully flagged video: Funny Dogs (reason: Not supplied)"));
+  EXPECT_THAT(
+      commandOutput[1],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: Not supplied)"));
+  EXPECT_THAT(
+      commandOutput[2],
+      HasSubstr(
+          "Successfully flagged video: Another Cat Video (reason: Not supplied)"));
+  EXPECT_THAT(
+      commandOutput[3],
+       HasSubstr(
+          "Successfully flagged video: Life at Google (reason: Not supplied)"));
+  EXPECT_THAT(
+      commandOutput[4],
+      HasSubstr(
+          "Successfully flagged video: Video about nothing (reason: Not supplied)"));
+  EXPECT_THAT(commandOutput[5], HasSubstr("No videos available"));
+}
+
+TEST(Part4, flagVideoAddVideoToPlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.flagVideo("amazing_cats_video_id");
+  videoPlayer.createPlaylist("my_playlist");
+  videoPlayer.addVideoToPlaylist("my_playlist", "amazing_cats_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 3);
+  EXPECT_THAT(
+  commandOutput[0],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: Not supplied)"));
+  EXPECT_THAT(commandOutput[1],
+              HasSubstr("Successfully created new playlist: my_playlist"));
+  EXPECT_THAT(commandOutput[2],
+              HasSubstr("Cannot add video to my_playlist: Video is "
+                        "currently flagged (reason: Not supplied)"));
+}
+
+TEST(Part4, flagVideoShowPlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("my_playlist");
+  videoPlayer.addVideoToPlaylist("my_playlist", "amazing_cats_video_id");
+  videoPlayer.flagVideo("amazing_cats_video_id", "dont_like_cats");
+  videoPlayer.showPlaylist("my_playlist");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 5);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Successfully created new playlist: my_playlist"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Added video to my_playlist: Amazing Cats"));
+  EXPECT_THAT(
+      commandOutput[2],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: dont_like_cats)"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Showing playlist: my_playlist"));
+  EXPECT_THAT(commandOutput[4], HasSubstr("Amazing Cats (amazing_cats_video_id) [#cat "
+                                "#animal] - FLAGGED (reason: dont_like_cats)"));
+}
+
+TEST(Part4, flagVideoShowAllVideos) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.flagVideo("amazing_cats_video_id", "dont_like_cats");
+  videoPlayer.showAllVideos();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 7);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: dont_like_cats)"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Here's a list of all available videos:"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("Amazing Cats (amazing_cats_video_id) [#cat "
+                                "#animal] - FLAGGED (reason: dont_like_cats)"));
+  EXPECT_THAT(
+      commandOutput[3],
+      HasSubstr("Another Cat Video (another_cat_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[4],
+              HasSubstr("Funny Dogs (funny_dogs_video_id) [#dog #animal]"));
+  EXPECT_THAT(
+      commandOutput[5],
+      HasSubstr("Life at Google (life_at_google_video_id) [#google #career]"));
+  EXPECT_THAT(
+      commandOutput[6],
+      HasSubstr("Video about nothing (nothing_video_id) []"));    
+}
+
+TEST(Part4, flagVideoSearchVideos) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  std::streambuf* orig = std::cin.rdbuf();
+  std::istringstream input("no");
+  std::cin.rdbuf(input.rdbuf());
+  videoPlayer.flagVideo("amazing_cats_video_id", "dont_like_cats");
+  videoPlayer.searchVideos("cat");
+  std::cin.rdbuf(orig);
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 5);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: dont_like_cats)"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Here are the results for cat:"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("1) Another Cat Video (another_cat_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Would you like to play any of the above? If "
+                                "yes, specify the number of the video."));
+  EXPECT_THAT(
+      commandOutput[4],
+      HasSubstr(
+          "If your answer is not a valid number, we will assume it's a no."));
+}
+
+TEST(Part4, flagVideoSearchVideosWithTag) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  std::streambuf* orig = std::cin.rdbuf();
+  std::istringstream input("no");
+  std::cin.rdbuf(input.rdbuf());
+  videoPlayer.flagVideo("amazing_cats_video_id", "dont_like_cats");
+  videoPlayer.searchVideosWithTag("#cat");
+  std::cin.rdbuf(orig);
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 5);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: dont_like_cats)"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Here are the results for #cat:"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("1) Another Cat Video (another_cat_video_id) [#cat #animal]"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Would you like to play any of the above? If "
+                                "yes, specify the number of the video."));
+  EXPECT_THAT(
+      commandOutput[4],
+      HasSubstr(
+          "If your answer is not a valid number, we will assume it's a no."));
+}
+
+TEST(Part4, flagVideoStopPlayingVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.flagVideo("amazing_cats_video_id", "dont_like_cats");
+  videoPlayer.showPlaying();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 4);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Stopping video: Amazing Cats"));
+  EXPECT_THAT(
+      commandOutput[2],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: dont_like_cats)"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("No video is currently playing"));
+}
+
+TEST(Part4, flagVideoStopPausedVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.pauseVideo();
+  videoPlayer.flagVideo("amazing_cats_video_id", "dont_like_cats");
+  videoPlayer.showPlaying();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 5);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Pausing video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[2], HasSubstr("Stopping video: Amazing Cats"));
+  EXPECT_THAT(
+      commandOutput[3],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: dont_like_cats)"));
+  EXPECT_THAT(commandOutput[4], HasSubstr("No video is currently playing"));
+}
+
+TEST(Part4, flagVideoKeepVideoPlayingIfDifferentFromFlaggedVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.playVideo("amazing_cats_video_id");
+  videoPlayer.flagVideo("another_cat_video_id", "dont_like_cats");
+  videoPlayer.showPlaying();
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 3);
+  EXPECT_THAT(commandOutput[0], HasSubstr("Playing video: Amazing Cats"));
+  EXPECT_THAT(
+      commandOutput[1],
+      HasSubstr(
+          "Successfully flagged video: Another Cat Video (reason: dont_like_cats)"));
+  EXPECT_THAT(commandOutput[2],
+      HasSubstr("Currently playing: Amazing Cats "
+                "(amazing_cats_video_id) [#cat #animal]"));
+}
+
+TEST(Part4, allowVideo) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.flagVideo("amazing_cats_video_id", "dont_like_cats");
+  videoPlayer.allowVideo("amazing_cats_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 2);
+  EXPECT_THAT(
+      commandOutput[0],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: dont_like_cats)"));
+  EXPECT_THAT(commandOutput[1],
+              HasSubstr("Successfully removed flag from video: Amazing Cats"));
+}
+
+TEST(Part4, allowVideoNotFlagged) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.allowVideo("amazing_cats_video_id");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Cannot remove flag from video: Video is not flagged"));
+}
+
+TEST(Part4, allowVideoNonexistent) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.allowVideo("video_does_not_exist");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 1);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Cannot remove flag from video: Video does not exist"));
+}
+
+TEST(Part4, allowVideoShowPlaylist) {
+  VideoPlayer videoPlayer = VideoPlayer();
+  testing::internal::CaptureStdout();
+  videoPlayer.createPlaylist("my_playlist");
+  videoPlayer.addVideoToPlaylist("my_playlist", "amazing_cats_video_id");
+  videoPlayer.flagVideo("amazing_cats_video_id", "dont_like_cats");
+  videoPlayer.showPlaylist("my_playlist");
+  videoPlayer.allowVideo("amazing_cats_video_id");
+  videoPlayer.showPlaylist("my_playlist");
+  std::string output = testing::internal::GetCapturedStdout();
+  std::vector<std::string> commandOutput = splitlines(output);
+  ASSERT_EQ(commandOutput.size(), 8);
+  EXPECT_THAT(commandOutput[0],
+              HasSubstr("Successfully created new playlist: my_playlist"));
+  EXPECT_THAT(commandOutput[1], HasSubstr("Added video to my_playlist: Amazing Cats"));
+  EXPECT_THAT(
+      commandOutput[2],
+      HasSubstr(
+          "Successfully flagged video: Amazing Cats (reason: dont_like_cats)"));
+  EXPECT_THAT(commandOutput[3], HasSubstr("Showing playlist: my_playlist"));
+  EXPECT_THAT(commandOutput[4], HasSubstr("Amazing Cats (amazing_cats_video_id) [#cat "
+                                "#animal] - FLAGGED (reason: dont_like_cats)"));
+  EXPECT_THAT(commandOutput[5],
+              HasSubstr("Successfully removed flag from video: Amazing Cats"));
+  EXPECT_THAT(commandOutput[7],
+              HasSubstr("Amazing Cats (amazing_cats_video_id) [#cat #animal]"));
+}
diff --git a/solutions/cpp/solution1/test/videolibrary_test.cpp b/solutions/cpp/solution1/test/videolibrary_test.cpp
new file mode 100644
index 0000000..d74813f
--- /dev/null
+++ b/solutions/cpp/solution1/test/videolibrary_test.cpp
@@ -0,0 +1,32 @@
+#include "../src/videolibrary.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "../src/video.h"
+
+using ::testing::ContainsRegex;
+using ::testing::HasSubstr;
+
+TEST(VideoLibrary, VideoLibraryHasAllVideos) {
+  VideoLibrary videoLibrary = VideoLibrary();
+  EXPECT_EQ(videoLibrary.getVideos().size(), 5);
+}
+
+TEST(VideoLibrary, VideoLibraryParsesTagsCorrectly) {
+  std::vector<std::string> tags{"#cat", "#animal"};
+  VideoLibrary videoLibrary = VideoLibrary();
+  const Video *video = videoLibrary.getVideo("amazing_cats_video_id");
+  bool result = std::equal(tags.begin(), tags.end(), video->getTags().begin());
+  EXPECT_EQ("Amazing Cats", video->getTitle());
+  EXPECT_EQ("amazing_cats_video_id", video->getVideoId());
+  EXPECT_TRUE(result);
+}
+
+TEST(VideoLibrary, testLibraryParsesVideoCorrectlyWithoutTags) {
+  VideoLibrary videoLibrary = VideoLibrary();
+  const Video *video = videoLibrary.getVideo("nothing_video_id");
+  EXPECT_EQ("Video about nothing", video->getTitle());
+  EXPECT_EQ("nothing_video_id", video->getVideoId());
+  EXPECT_TRUE(video->getTags().empty());
+}
diff --git a/solutions/python/solution1/README.md b/solutions/python/solution1/README.md
new file mode 100644
index 0000000..d259b4a
--- /dev/null
+++ b/solutions/python/solution1/README.md
@@ -0,0 +1,72 @@
+# Youtube Challenge - Python
+The Python Youtube Challenge uses Python3. 
+The below commands use Python3 specifically, to account for users that might 
+have Python2 installed alongside Python3.
+
+NOTE: **Please do not edit videos.txt as it will cause tests to break. There is no need to modify this file to complete this challenge.**
+
+## Installing Python and pytest
+[This guide](https://realpython.com/installing-python/) explains how to check if you already
+have Python installed, and if not, how to install it on your machine.
+Please make sure you install Python 3.7 or higher.
+
+The tests are using `pytest`, if you don't have `pytest` installed yet, you can do so by running:
+```shell script
+python3 -m pip install pytest
+```
+
+pip should be installed already if you installed Python from the official source. If not, you
+can find many guides online on how to install pip for your operating system.
+
+## Setting up
+You can write code in any editor you'd like. However, different editors have 
+different ways of dealing with Python code, so in case of doubt we recommend 
+you run the code and tests from the command line as shown  below.
+
+## Running and testing from the Commandline
+To run the command-line application:
+```shell script
+python3 -m src.run
+```
+
+You can close the app by typing `EXIT` as a command.
+
+#### Running the tests
+To run all the tests:
+```shell script
+python3 -m pytest
+```
+For more verbose test output you can use
+```shell script
+python3 -m pytest -v
+```
+
+```shell script
+python3 -m pytest test/part1_test.py
+python3 -m pytest test/part2_test.py
+python3 -m pytest test/part3_test.py
+python3 -m pytest test/part4_test.py
+```
+
+For more information on pytest commandline options, such as only running a specific test,
+you can read more [here](https://docs.pytest.org/en/6.2.x/usage.html#).
+
+## Running and testing from IntelliJ/PyCharm
+* Mark both the `python/` and `src/` directory as Sources Root
+    * (Right-click on src/ > Mark Directory As > Sources Root )
+* Mark the  `test/` directory as Test Sources Root
+    * (Right-click on test/ > Mark Directory As > Test Sources Root)
+
+This will allow your editor to correctly index the project.
+
+To run the Application, create a new "Run/Debug configuration":
+* Run > Edit Configurations > "+" Button > Python
+![intellij_setup](intellij_setup.png)
+
+To run the tests, add a pytest configuration as follows:
+* Run > Edit Configurations > "+" Button > Python tests > pytest
+
+![intellij_test_setup](intellij_test_setup.png)
+
+Then you will be able to run and debug the unit tests.
+
diff --git a/solutions/python/solution1/intellij_setup.png b/solutions/python/solution1/intellij_setup.png
new file mode 100644
index 0000000..8d99b11
Binary files /dev/null and b/solutions/python/solution1/intellij_setup.png differ
diff --git a/solutions/python/solution1/intellij_test_setup.png b/solutions/python/solution1/intellij_test_setup.png
new file mode 100644
index 0000000..788cb45
Binary files /dev/null and b/solutions/python/solution1/intellij_test_setup.png differ
diff --git a/solutions/python/solution1/src/__init__.py b/solutions/python/solution1/src/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/solutions/python/solution1/src/command_parser.py b/solutions/python/solution1/src/command_parser.py
new file mode 100644
index 0000000..dc59a46
--- /dev/null
+++ b/solutions/python/solution1/src/command_parser.py
@@ -0,0 +1,163 @@
+"""A command parser class."""
+
+import textwrap
+from typing import Sequence
+
+
+class CommandException(Exception):
+    """A class used to represent a wrong command exception."""
+    pass
+
+
+class CommandParser:
+    """A class used to parse and execute a user Command."""
+
+    def __init__(self, video_player):
+        self._player = video_player
+
+    def execute_command(self, command: Sequence[str]):
+        """Executes the user command. Expects the command to be upper case.
+           Raises CommandException if a command cannot be parsed.
+        """
+        if not command:
+            raise CommandException(
+                "Please enter a valid command, "
+                "type HELP for a list of available commands.")
+
+        if command[0].upper() == "NUMBER_OF_VIDEOS":
+            self._player.number_of_videos()
+
+        elif command[0].upper() == "SHOW_ALL_VIDEOS":
+            self._player.show_all_videos()
+
+        elif command[0].upper() == "PLAY":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter PLAY command followed by video_id.")
+            self._player.play_video(command[1])
+
+        elif command[0].upper() == "PLAY_RANDOM":
+            self._player.play_random_video()
+
+        elif command[0].upper() == "STOP":
+            self._player.stop_video()
+
+        elif command[0].upper() == "PAUSE":
+            self._player.pause_video()
+
+        elif command[0].upper() == "CONTINUE":
+            self._player.continue_video()
+
+        elif command[0].upper() == "SHOW_PLAYING":
+            self._player.show_playing()
+
+        elif command[0].upper() == "CREATE_PLAYLIST":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter CREATE_PLAYLIST command followed by a "
+                    "playlist name.")
+            self._player.create_playlist(command[1])
+
+        elif command[0].upper() == "ADD_TO_PLAYLIST":
+            if len(command) != 3:
+                raise CommandException(
+                    "Please enter ADD_TO_PLAYLIST command followed by a "
+                    "playlist name and video_id to add.")
+            self._player.add_to_playlist(command[1], command[2])
+
+        elif command[0].upper() == "REMOVE_FROM_PLAYLIST":
+            if len(command) != 3:
+                raise CommandException(
+                    "Please enter REMOVE_FROM_PLAYLIST command followed by a "
+                    "playlist name and video_id to remove.")
+            self._player.remove_from_playlist(command[1], command[2])
+
+        elif command[0].upper() == "CLEAR_PLAYLIST":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter CLEAR_PLAYLIST command followed by a "
+                    "playlist name.")
+            self._player.clear_playlist(command[1])
+
+        elif command[0].upper() == "DELETE_PLAYLIST":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter DELETE_PLAYLIST command followed by a "
+                    "playlist name.")
+            self._player.delete_playlist(command[1])
+
+        elif command[0].upper() == "SHOW_PLAYLIST":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter SHOW_PLAYLIST command followed by a "
+                    "playlist name.")
+            self._player.show_playlist(command[1])
+
+        elif command[0].upper() == "SHOW_ALL_PLAYLISTS":
+            self._player.show_all_playlists()
+
+        elif command[0].upper() == "SEARCH_VIDEOS":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter SEARCH_VIDEOS command followed by a "
+                    "search term.")
+            self._player.search_videos(command[1])
+
+        elif command[0].upper() == "SEARCH_VIDEOS_WITH_TAG":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter SEARCH_VIDEOS_WITH_TAG command followed by a "
+                    "video tag.")
+            self._player.search_videos_tag(command[1])
+
+        elif command[0].upper() == "FLAG_VIDEO":
+            if len(command) == 3:
+                self._player.flag_video(command[1], command[2])
+            elif len(command) == 2:
+                self._player.flag_video(command[1])
+            else:
+                raise CommandException(
+                    "Please enter FLAG_VIDEO command followed by a "
+                    "video_id and an optional flag reason.")
+
+        elif command[0].upper() == "ALLOW_VIDEO":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter ALLOW_VIDEO command followed by a "
+                    "video_id.")
+            self._player.allow_video(command[1])
+
+        elif command[0].upper() == "HELP":
+            self._get_help()
+        else:
+            print(
+                "Please enter a valid command, type HELP for a list of "
+                "available commands.")
+
+    def _get_help(self):
+        """Displays all available commands to the user."""
+        help_text = textwrap.dedent("""
+        Available commands:
+            NUMBER_OF_VIDEOS - Shows how many videos are in the library.
+            SHOW_ALL_VIDEOS - Lists all videos from the library.
+            PLAY <video_id> - Plays specified video.
+            PLAY_RANDOM - Plays a random video from the library.
+            STOP - Stop the current video.
+            PAUSE - Pause the current video.
+            CONTINUE - Resume the current paused video.
+            SHOW_PLAYING - Displays the title, url and paused status of the video that is currently playing (or paused).
+            CREATE_PLAYLIST <playlist_name> - Creates a new (empty) playlist with the provided name.
+            ADD_TO_PLAYLIST <playlist_name> <video_id> - Adds the requested video to the playlist.
+            REMOVE_FROM_PLAYLIST <playlist_name> <video_id> - Removes the specified video from the specified playlist
+            CLEAR_PLAYLIST <playlist_name> - Removes all the videos from the playlist.
+            DELETE_PLAYLIST <playlist_name> - Deletes the playlist.
+            SHOW_PLAYLIST <playlist_name> - List all the videos in this playlist.
+            SHOW_ALL_PLAYLISTS - Display all the available playlists.
+            SEARCH_VIDEOS <search_term> - Display all the videos whose titles contain the search_term.
+            SEARCH_VIDEOS_WITH_TAG <tag_name> -Display all videos whose tags contains the provided tag.
+            FLAG_VIDEO <video_id> <flag_reason> - Mark a video as flagged.
+            ALLOW_VIDEO <video_id> - Removes a flag from a video.
+            HELP - Displays help.
+            EXIT - Terminates the program execution.
+        """)
+        print(help_text)
diff --git a/solutions/python/solution1/src/run.py b/solutions/python/solution1/src/run.py
new file mode 100644
index 0000000..dbb22c0
--- /dev/null
+++ b/solutions/python/solution1/src/run.py
@@ -0,0 +1,21 @@
+"""A youtube terminal simulator."""
+from .video_player import VideoPlayer
+from .command_parser import CommandException
+from .command_parser import CommandParser
+
+
+if __name__ == "__main__":
+    print("""Hello and welcome to YouTube, what would you like to do?
+    Enter HELP for list of available commands or EXIT to terminate.""")
+    video_player = VideoPlayer()
+    parser = CommandParser(video_player)
+    while True:
+        command = input("YT> ")
+        if command.upper() == "EXIT":
+            break
+        try:
+            parser.execute_command(command.split())
+        except CommandException as e:
+            print(e)
+    print("YouTube has now terminated its execution. "
+          "Thank you and goodbye!")
diff --git a/solutions/python/solution1/src/video.py b/solutions/python/solution1/src/video.py
new file mode 100644
index 0000000..42fe1fe
--- /dev/null
+++ b/solutions/python/solution1/src/video.py
@@ -0,0 +1,80 @@
+"""A video class."""
+
+from typing import Sequence
+
+class FlagError(Exception):
+    pass
+
+class Video:
+    """A class used to represent a Video."""
+
+    def __init__(self, video_title: str, video_id: str, video_tags: Sequence[str]):
+        """Video constructor."""
+        self._title = video_title
+        self._video_id = video_id
+
+        # Turn the tags into a tuple here so it's unmodifiable,
+        # in case the caller changes the 'video_tags' they passed to us
+        self._tags = tuple(video_tags)
+        # When the flag reason is None it means the video is not flagged
+        # This allows us to not need a self._is_flagged.
+        self._flag_reason = None
+
+    @property
+    def title(self) -> str:
+        """Returns the title of a video."""
+        return self._title
+
+    @property
+    def video_id(self) -> str:
+        """Returns the video id of a video."""
+        return self._video_id
+
+    @property
+    def tags(self) -> Sequence[str]:
+        """Returns the list of tags of a video."""
+        return self._tags
+
+    @property
+    def tags_string(self) -> str:
+        """Returns the tags as a string, like "#cat #animal"
+        separated by spaces"""
+        return ' '.join(self.tags)
+
+    def __str__(self):
+        """This function prints the video when you do print(video) like
+        Amazing Cats (amazing_cats_video_id) [#cat #animal]
+        """
+        result = f'{self.title} ({self.video_id}) [{self.tags_string}]'
+        if self.is_flagged:
+            result += f' - FLAGGED {self.formatted_flag_reason}'
+        return result
+
+    def flag(self, flag_reason: str):
+        if self.is_flagged:
+            raise FlagError("Video is already flagged")
+        self._flag_reason = flag_reason
+
+    def unflag(self):
+        if not self.is_flagged:
+            raise FlagError("Video is not flagged")
+        self._flag_reason = None
+
+    @property
+    def is_flagged(self):
+        """Return True if the flag reason is not None"""
+        return self._flag_reason is not None
+
+    def check_allowed(self):
+        """Return True if the video is not currently flagged"""
+        if self.is_flagged:
+            raise FlagError(f"Video is currently flagged {self.formatted_flag_reason}")
+
+    @property
+    def formatted_flag_reason(self):
+        """Format the flag reason properly. If it's not flagged we can
+        return an empty string."""
+        if self.is_flagged:
+            return f'(reason: {self._flag_reason})'
+        else:
+            return ''
diff --git a/solutions/python/solution1/src/video_library.py b/solutions/python/solution1/src/video_library.py
new file mode 100644
index 0000000..8f33b54
--- /dev/null
+++ b/solutions/python/solution1/src/video_library.py
@@ -0,0 +1,90 @@
+"""A video library class."""
+
+from typing import Sequence, Optional
+
+import csv
+import random
+from pathlib import Path
+
+from .video import Video
+
+
+# Helper Wrapper around CSV reader to strip whitespace from around
+# each item.
+def _csv_reader_with_strip(reader):
+    yield from ((item.strip() for item in line) for line in reader)
+
+
+class VideoLibraryError(Exception):
+    pass
+
+
+class VideoLibrary:
+    """A class used to represent a Video Library."""
+
+    def __init__(self):
+        """The VideoLibrary class is initialized."""
+        self._videos = {}
+        with open(Path(__file__).parent / "videos.txt") as video_file:
+            reader = _csv_reader_with_strip(
+                csv.reader(video_file, delimiter="|"))
+            for video_info in reader:
+                title, url, tags = video_info
+                self._videos[url] = Video(
+                    title,
+                    url,
+                    [tag.strip() for tag in tags.split(",")] if tags else [],
+                )
+
+    def get_all_videos(self) -> Sequence[Video]:
+        """Returns all available video information from the video library."""
+        return list(sorted(self._videos.values(), key=str))
+
+    def get_allowed_videos(self) -> Sequence[Video]:
+        """Returns all allowed videos in the library."""
+        return [v for v in self.get_all_videos() if not v.is_flagged]
+
+    def __getitem__(self, video_id):
+        """This is a way to make the Video library behave like a python
+        dictionary. So now we can do video_library[video_id] and it will
+        return the video if it exists ot throw a VideoLibraryError.
+
+        See also: https://www.kite.com/python/answers/how-to-override-the-[]-operator-in-python
+        """
+        try:
+            return self._videos[video_id]
+        except KeyError:
+            raise VideoLibraryError("Video does not exist")
+
+    def get_video(self, video_id: str) -> Optional[Video]:
+        """Returns the video object (title, url, tags) from the video library.
+
+        Args:
+            video_id: The video url.
+
+        Returns:
+            The Video object for the requested video_id. None if the video
+            does not exist.
+        """
+        return self._videos.get(video_id, None)
+
+    def get_random_video_id(self) -> Optional[str]:
+        """Returns a Random Video id from the list of allowed videos.
+        If there are no videos available (e.g. all of them are flagged or
+        something else happened) we return None.
+        """
+        try:
+            return random.choice([video.video_id for video in self.get_allowed_videos()])
+        except IndexError:
+            return None
+
+    def search_videos(self, search_term: str):
+        """Search through all the titles (in lower case) and return if the title
+        contains the search term."""
+        search_term = search_term.lower()
+        return [v for v in self.get_allowed_videos() if search_term in v.title.lower()]
+
+    def get_videos_with_tag(self, tag: str):
+        """Search through all the tags and return all videos whose tags
+        contain the search tag."""
+        return [v for v in self.get_allowed_videos() if tag in v.tags]
diff --git a/solutions/python/solution1/src/video_playback.py b/solutions/python/solution1/src/video_playback.py
new file mode 100644
index 0000000..6a2ebfe
--- /dev/null
+++ b/solutions/python/solution1/src/video_playback.py
@@ -0,0 +1,56 @@
+import enum
+
+class VideoPlaybackError(Exception):
+    pass
+
+
+class PlaybackState(enum.Enum):
+    STOPPED = 0
+    PAUSED = 1
+    PLAYING = 2
+
+
+class VideoPlayback:
+    """A class to keep track of the currently playing video and it's state
+    (PAUSED, STOPPED, PLAYING).
+
+    We need to make sure we keep the two together because when no video is
+    currently playing, it can also not be paused.
+    """
+    def __init__(self):
+        self._video = None
+        self._state = PlaybackState.STOPPED
+
+    def play(self, video):
+        self._video = video
+        self._state = PlaybackState.PLAYING
+
+    def pause(self):
+        self._check_video()
+        self._state = PlaybackState.PAUSED
+
+    def resume(self):
+        self._check_video()
+
+        if self._state != PlaybackState.PAUSED:
+            raise VideoPlaybackError("Video is not paused")
+
+        self._state = PlaybackState.PLAYING
+
+    def stop(self):
+        self._check_video()
+        self._video = None
+        self._state = PlaybackState.STOPPED
+
+    def get_video(self):
+        self._check_video()
+        return self._video
+
+    @property
+    def state(self):
+        return self._state
+
+    def _check_video(self):
+        """Check to make sure that there is a video currently playing."""
+        if self._video is None:
+            raise VideoPlaybackError("No video is currently playing")
diff --git a/solutions/python/solution1/src/video_player.py b/solutions/python/solution1/src/video_player.py
new file mode 100644
index 0000000..a4dab4b
--- /dev/null
+++ b/solutions/python/solution1/src/video_player.py
@@ -0,0 +1,314 @@
+"""A video player class."""
+
+import random
+from .video_library import VideoLibrary, VideoLibraryError
+from . import video_playlist_library
+from .video import FlagError
+from .video_playlist import VideoPlaylistError
+from .video_playlist_library import VideoPlaylistLibraryError
+from .video_playback import VideoPlayback, VideoPlaybackError, PlaybackState
+
+
+class VideoPlayerError(Exception):
+    pass
+
+
+def _print_video_choice_list(videos):
+    for i, video in enumerate(videos, start=1):
+        print(f"  {i}) {video})")
+
+    print("Would you like to play any of the above? If yes, specify the number of the video.")
+    print("If your answer is not a valid number, we will assume it's a no.")
+
+    user_input = input("")
+
+    try:
+        num = int(user_input)
+    except ValueError:
+        num = 0
+
+    if 1 <= num <= len(videos):
+        return videos[num - 1]
+    else:
+        return None
+
+
+class VideoPlayer:
+    """A class used to represent a Video Player."""
+
+    def __init__(self):
+        """The VideoPlayer class is initialized."""
+        self._videos = VideoLibrary()
+        self._playlists = video_playlist_library.VideoPlaylistLibrary()
+        self._playback = VideoPlayback()
+
+
+    def number_of_videos(self):
+        num_videos = len(self._videos.get_all_videos())
+        print(f"{num_videos} videos in the library")
+
+
+    def show_all_videos(self):
+        """Returns all videos."""
+
+        print("Here's a list of all available videos:")
+        for v in self._videos.get_all_videos():
+            print(v)
+
+    def play_video(self, video_id):
+        """Plays the respective video.
+
+        Args:
+            video_id: The video_id to be played.
+        """
+
+        try:
+            video = self._videos[video_id]
+            video.check_allowed()
+        except (VideoLibraryError, FlagError) as e:
+            print(f"Cannot play video: {e}")
+            return
+
+        if self._playback.state != PlaybackState.STOPPED:
+            self.stop_video()
+        self._playback.play(video)
+        print(f"Playing video: {video.title}")
+
+    def stop_video(self):
+        """Stops the current video."""
+
+        try:
+            video = self._playback.get_video()
+            print(f"Stopping video: {video.title}")
+            self._playback.stop()
+        except VideoPlaybackError as e:
+            print(f"Cannot stop video: {e}")
+
+    def play_random_video(self):
+        """Plays a random video from the video library."""
+
+        random_video_id = self._videos.get_random_video_id()
+
+        if random_video_id is None:
+            print("No videos available")
+        else:
+            self.play_video(random_video_id)
+
+    def pause_video(self):
+        """Pauses the current video."""
+
+        try:
+            video = self._playback.get_video()
+        except VideoPlaybackError as e:
+            print(f"Cannot pause video: {e}")
+            return
+
+        if self._playback.state == PlaybackState.PAUSED:
+            print(f"Video already paused: {video.title}")
+            return
+
+        print(f"Pausing video: {video.title}")
+        self._playback.pause()
+
+    def continue_video(self):
+        """Resumes playing the current video."""
+
+        try:
+            video = self._playback.get_video()
+            self._playback.resume()
+            print(f"Continuing video: {video.title}")
+        except VideoPlaybackError as e:
+            print(f"Cannot continue video: {e}")
+
+    def show_playing(self):
+        """Displays video currently playing."""
+
+        if self._playback.state == PlaybackState.PLAYING:
+            print(f"Currently playing: {self._playback.get_video()}")
+        elif self._playback.state == PlaybackState.PAUSED:
+            print(f"Currently playing: {self._playback.get_video()} - PAUSED")
+        else:
+            print("No video is currently playing")
+
+    def create_playlist(self, playlist_name):
+        """Creates a playlist with a given name.
+
+        Args:
+            playlist_name: The playlist name.
+        """
+
+        try:
+            self._playlists.create(playlist_name)
+            print(f"Successfully created new playlist: {playlist_name}")
+        except VideoPlaylistLibraryError as e:
+            print(f"Cannot create playlist: {e}")            
+
+    def add_to_playlist(self, playlist_name, video_id):
+        """Adds a video to a playlist with a given name.
+
+        Args:
+            playlist_name: The playlist name.
+            video_id: The video_id to be added.
+        """
+
+        try:
+            playlist = self._playlists[playlist_name]
+            video = self._videos[video_id]
+            video.check_allowed()
+            playlist.add_video(video)
+            print(f"Added video to {playlist_name}: {video.title}")
+        except (VideoPlaylistLibraryError, VideoPlaylistError, VideoLibraryError, FlagError) as e:
+            print(f"Cannot add video to {playlist_name}: {e}")
+
+    def show_all_playlists(self):
+        """Display all playlists."""
+
+        playlists = list(self._playlists.get_all())
+
+        if not playlists:
+            print("No playlists exist yet")
+            return
+
+        print("Showing all playlists:")
+        for playlist in playlists:
+            print(f"  {playlist}")
+
+    def show_playlist(self, playlist_name):
+        """Display all videos in a playlist with a given name.
+
+        Args:
+            playlist_name: The playlist name.
+        """
+
+        try:        
+            playlist = self._playlists[playlist_name]
+        except VideoPlaylistLibraryError as e:
+            print(f"Cannot show playlist {playlist_name}: {e}")
+            return
+
+        print(f"Showing playlist: {playlist_name}")
+
+        if not playlist.videos:
+            print("No videos here yet")
+            return
+
+        for video in playlist.videos:
+            print(f"  {video}")
+
+    def remove_from_playlist(self, playlist_name, video_id):
+        """Removes a video to a playlist with a given name.
+
+        Args:
+            playlist_name: The playlist name.
+            video_id: The video_id to be removed.
+        """
+
+        try:
+            playlist = self._playlists[playlist_name]
+            video = self._videos[video_id]
+            playlist.remove_video(video)
+            print(f"Removed video from {playlist_name}: {video.title}")
+        except (VideoPlaylistError, VideoLibraryError, VideoPlaylistLibraryError) as e:
+            print(f"Cannot remove video from {playlist_name}: {e}")
+
+    def clear_playlist(self, playlist_name):
+        """Removes all videos from a playlist with a given name.
+
+        Args:
+            playlist_name: The playlist name.
+        """
+
+        try:        
+            playlist = self._playlists[playlist_name]
+            playlist.clear()
+            print(f"Successfully removed all videos from {playlist_name}")
+        except (VideoPlaylistError, VideoPlaylistLibraryError) as e:
+            print(f"Cannot clear playlist {playlist_name}: {e}")
+
+    def delete_playlist(self, playlist_name):
+        """Deletes a playlist with a given name.
+
+        Args:
+            playlist_name: The playlist name.
+        """
+
+        try:        
+            playlist = self._playlists[playlist_name]
+            del self._playlists[playlist_name]
+            print(f"Deleted playlist: {playlist_name}")
+        except VideoPlaylistLibraryError as e:
+            print(f"Cannot delete playlist {playlist_name}: {e}")
+
+    def search_videos(self, search_term):
+        """Display all the videos whose titles contain the search_term.
+
+        Args:
+            search_term: The query to be used in search.
+        """
+        
+        results = self._videos.search_videos(search_term)
+
+        if not results:
+            print(f"No search results for {search_term}")
+            return
+
+        print(f"Here are the results for {search_term}:")
+        chosen_video = _print_video_choice_list(results)
+
+        if chosen_video is not None:
+            self.play_video(chosen_video.video_id)
+
+    def search_videos_tag(self, video_tag):
+        """Display all videos whose tags contains the provided tag.
+
+        Args:
+            video_tag: The video tag to be used in search.
+        """
+
+        results = self._videos.get_videos_with_tag(video_tag)
+
+        if not results:
+            print(f"No search results for {video_tag}")
+            return
+
+        print(f"Here are the results for {video_tag}:")
+        chosen_video = _print_video_choice_list(results)
+
+        if chosen_video is not None:
+            self.play_video(chosen_video.video_id)
+
+    def flag_video(self, video_id, flag_reason=""):
+        """Mark a video as flagged.
+
+        Args:
+            video_id: The video_id to be flagged.
+            flag_reason: Reason for flagging the video.
+        """
+
+        if not flag_reason:
+            flag_reason = "Not supplied"
+
+        try:
+            video = self._videos[video_id]
+
+            if self._playback.state != PlaybackState.STOPPED and self._playback.get_video() == video:
+                self.stop_video()
+
+            video.flag(flag_reason)
+            print(f"Successfully flagged video: {video.title} {video.formatted_flag_reason}")
+        except (VideoPlayerError, FlagError, VideoLibraryError) as e:
+            print(f"Cannot flag video: {e}")
+
+    def allow_video(self, video_id):
+        """Removes a flag from a video.
+
+        Args:
+            video_id: The video_id to be allowed again.
+        """
+
+        try:
+            video = self._videos[video_id]
+            video.unflag()
+            print(f"Successfully removed flag from video: {video.title}")
+        except (VideoPlayerError, FlagError, VideoLibraryError) as e:
+            print(f"Cannot remove flag from video: {e}")
diff --git a/solutions/python/solution1/src/video_playlist.py b/solutions/python/solution1/src/video_playlist.py
new file mode 100644
index 0000000..4009fa3
--- /dev/null
+++ b/solutions/python/solution1/src/video_playlist.py
@@ -0,0 +1,44 @@
+"""A video playlist class."""
+
+class VideoPlaylistError(Exception):
+    pass
+
+
+class VideoPlaylist:
+    """A class used to represent a Playlist."""
+
+    def __init__(self, name:str):
+        self._name = name
+        # Keep the videos as a list
+        self._videos = []
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def videos(self):
+        return tuple(self._videos)
+
+    def __contains__(self, video):
+        """Overloading this method will allow us to use the python "in"
+        operator. So now we can do `if video in playlist` like it was a list."""
+        return video in self._videos
+
+    def add_video(self, video):
+        if video in self:
+            raise VideoPlaylistError("Video already added")
+        self._videos.append(video)
+
+    def remove_video(self, video):
+        if video not in self:
+            raise VideoPlaylistError("Video is not in playlist")
+        self._videos.remove(video)
+
+    def clear(self):
+        self._videos.clear()
+
+    def __str__(self):
+        """Overloading __str__ allows us to use print(..) with this object.
+                When we do print(playlist) we just want to print the name."""
+        return self._name
diff --git a/solutions/python/solution1/src/video_playlist_library.py b/solutions/python/solution1/src/video_playlist_library.py
new file mode 100644
index 0000000..6798318
--- /dev/null
+++ b/solutions/python/solution1/src/video_playlist_library.py
@@ -0,0 +1,55 @@
+from .video_playlist import VideoPlaylist
+
+class VideoPlaylistLibraryError(Exception):
+    pass
+
+class VideoPlaylistLibrary:
+    """A library containing video playlists. We want this class to behave like
+    a python dictionary but with some additional functionality.
+    """
+    def __init__(self):
+        # keep the playlists indexed from lower-case name as key to
+        # Playlist object as value. This will help us with the lookup and
+        # maintaining the case.
+        self._playlists = {}
+
+    def __contains__(self, playlist_name: str):
+        """Overloading __contains__ allows us to use `in` like
+        `if playlist in video_library`. Here, we check if the playlist name
+        in lower case is part of the playlists.
+        """
+        return playlist_name.lower() in self._playlists
+
+    def create(self, playlist_name: str):
+        """Create a new playlist with the provided name and store it in the
+        dictionary with lowercase name for easier lookup in the future."""
+        if playlist_name in self:
+            raise VideoPlaylistLibraryError("A playlist with the same name already exists")
+        self._playlists[playlist_name.lower()] = VideoPlaylist(playlist_name)
+
+    def __getitem__(self, playlist_name):
+        """Overloading __getitem__ will allow us to use the [] operator for
+        the VideoPlaylistLibrary. e.g. we can do playlist_library[playlistname]
+        to retrieve a playlist from the library.
+
+        Here, we do the lookup in lowercase, because the playlist name should
+        not be case sensitive.
+        """
+        try:
+            return self._playlists[playlist_name.lower()]
+        except KeyError:
+            raise VideoPlaylistLibraryError("Playlist does not exist")
+
+    def get(self, playlist_name, default=None):
+        """Returns the playlist from the library or None if it doesn't
+        exist. We look up the playlist in lowercase because we don't care
+        about the case."""
+        return self._playlists.get(playlist_name.lower(), default)
+
+    def get_all(self):
+        return sorted(self._playlists.values(), key=str)
+
+    def __delitem__(self, playlist_name: str):
+        """This allows us to delete a playlist from the library without
+        caring about the case. """
+        del self._playlists[playlist_name.lower()]
diff --git a/solutions/python/solution1/src/videos.txt b/solutions/python/solution1/src/videos.txt
new file mode 100644
index 0000000..0800bb7
--- /dev/null
+++ b/solutions/python/solution1/src/videos.txt
@@ -0,0 +1,5 @@
+Funny Dogs | funny_dogs_video_id |  #dog , #animal
+Amazing Cats | amazing_cats_video_id |  #cat , #animal
+Another Cat Video | another_cat_video_id |  #cat , #animal
+Life at Google | life_at_google_video_id |  #google , #career
+Video about nothing | nothing_video_id |
\ No newline at end of file
diff --git a/solutions/python/solution1/test/part1_test.py b/solutions/python/solution1/test/part1_test.py
new file mode 100644
index 0000000..b2568a6
--- /dev/null
+++ b/solutions/python/solution1/test/part1_test.py
@@ -0,0 +1,238 @@
+import re
+from src.video_player import VideoPlayer
+
+
+def test_number_of_videos(capfd):
+    player = VideoPlayer()
+    player.number_of_videos()
+    out, err = capfd.readouterr()
+    assert "5 videos in the library" in out
+
+
+def test_show_all_videos(capfd):
+    player = VideoPlayer()
+    player.show_all_videos()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 6
+    assert "Here's a list of all available videos:" in lines[0]
+    assert "Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert "Funny Dogs (funny_dogs_video_id) [#dog #animal]" in lines[3]
+    assert "Life at Google (life_at_google_video_id) [#google #career]" in lines[4]
+    assert "Video about nothing (nothing_video_id) []" in lines[5]
+
+
+def test_play_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Playing video: Amazing Cats" in out
+
+
+def test_play_video_nonexistent(capfd):
+    player = VideoPlayer()
+    player.play_video("does_not_exist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot play video: Video does not exist" in out
+
+
+def test_play_video_stop_previous(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.play_video("funny_dogs_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Stopping video: Amazing Cats" in lines[1]
+    assert "Playing video: Funny Dogs" in lines[2]
+
+
+def test_play_video_dont_stop_previous_if_nonexistent(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.play_video("some_other_video")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Stopping video: Amazing Cats" not in out
+    assert "Cannot play video: Video does not exist" in lines[1]
+
+
+def test_stop_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.stop_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Stopping video: Amazing Cats" in lines[1]
+
+
+def test_stop_video_twice(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.stop_video()
+    player.stop_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Stopping video: Amazing Cats" in lines[1]
+    assert "Cannot stop video: No video is currently playing" in lines[2]
+
+
+def test_stop_video_none_playing(capfd):
+    player = VideoPlayer()
+    player.stop_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot stop video: No video is currently playing" in out
+
+
+def test_play_random_video(capfd):
+    player = VideoPlayer()
+    player.play_random_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert re.match(
+        "Playing video: (Amazing Cats|Another Cat Video|Funny Dogs|Life at Google|Video about nothing)",
+        out)
+
+
+def test_play_random_stops_previous_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.play_random_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Stopping video: Amazing Cats" in lines[1]
+    assert re.match(
+        "Playing video: (Amazing Cats|Another Cat Video|Funny Dogs|Life at Google|Video about nothing)",
+        lines[2])
+
+
+def test_show_playing(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Currently playing: Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+
+
+def test_show_nothing_playing(capfd):
+    player = VideoPlayer()
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "No video is currently playing" in lines[0]
+
+
+def test_pause_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.pause_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Pausing video: Amazing Cats" in lines[1]
+
+
+def test_pause_video_show_playing(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.pause_video()
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Currently playing: Amazing Cats (amazing_cats_video_id) " \
+           "[#cat #animal] - PAUSED" in lines[2]
+
+
+def test_pause_video_play_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.pause_video()
+    player.play_video("amazing_cats_video_id")
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Pausing video: Amazing Cats" in lines[1]
+    assert "Stopping video: Amazing Cats" in lines[2]
+    assert "Playing video: Amazing Cats" in lines[3]
+    assert "Currently playing: Amazing Cats (amazing_cats_video_id) " \
+           "[#cat #animal]" in lines[4]
+    assert "PAUSED" not in lines[4]
+
+
+def test_pause_already_paused_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.pause_video()
+    player.pause_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Pausing video: Amazing Cats" in lines[1]
+    assert "Video already paused: Amazing Cats" in lines[2]
+
+
+def test_pause_video_none_playing(capfd):
+    player = VideoPlayer()
+    player.pause_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot pause video: No video is currently playing" in lines[0]
+
+
+def test_continue_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.pause_video()
+    player.continue_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Pausing video: Amazing Cats" in lines[1]
+    assert "Continuing video: Amazing Cats" in lines[2]
+
+
+def test_continue_video_not_paused(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.continue_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Cannot continue video: Video is not paused" in lines[1]
+
+
+def test_continue_none_playing(capfd):
+    player = VideoPlayer()
+    player.continue_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot continue video: No video is currently playing" in lines[0]
diff --git a/solutions/python/solution1/test/part2_test.py b/solutions/python/solution1/test/part2_test.py
new file mode 100644
index 0000000..99ff02a
--- /dev/null
+++ b/solutions/python/solution1/test/part2_test.py
@@ -0,0 +1,237 @@
+from src.video_player import VideoPlayer
+
+
+def test_create_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_PLAYlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Successfully created new playlist: my_PLAYlist" in lines[0]
+
+
+def test_create_existing_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.create_playlist("my_COOL_PLAYLIST")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert ("Cannot create playlist: A playlist with the same name already "
+            "exists") in lines[1]
+
+
+def test_add_to_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_COOL_playlist")
+    player.add_to_playlist("my_cool_PLAYLIST", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully created new playlist: my_COOL_playlist" in lines[0]
+    assert "Added video to my_cool_PLAYLIST: Amazing Cats" in lines[1]
+
+
+def test_add_to_playlist_already_added(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Added video to my_cool_playlist: Amazing Cats" in lines[1]
+    assert "Cannot add video to my_cool_playlist: Video already added" in lines[2]
+
+
+def test_add_to_playlist_nonexistent_video(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    player.add_to_playlist("my_cool_playlist", "some_other_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Added video to my_cool_playlist: Amazing Cats" in lines[1]
+    assert "Cannot add video to my_cool_playlist: Video does not exist" in lines[2]
+
+
+def test_add_to_playlist_nonexistent_playlist(capfd):
+    player = VideoPlayer()
+    player.add_to_playlist("another_playlist", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot add video to another_playlist: Playlist does not exist" in lines[0]
+
+
+def test_add_to_playlist_nonexistent_playlist_nonexistent_video(capfd):
+    player = VideoPlayer()
+    player.add_to_playlist("another_playlist", "does_not_exist_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot add video to another_playlist: Playlist does not exist" in lines[0]
+
+
+def test_show_all_playlists_no_playlists_exist(capfd):
+    player = VideoPlayer()
+    player.show_all_playlists()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "No playlists exist yet" in lines[0]
+
+
+def test_show_all_playlists(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playLIST")
+    player.create_playlist("anotheR_playlist")
+    player.show_all_playlists()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Showing all playlists:" in lines[2]
+    assert "anotheR_playlist" in lines[3]
+    assert "my_cool_playLIST" in lines[4]
+
+
+def test_show_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.show_playlist("my_cool_playlist")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    player.show_playlist("my_COOL_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 6
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Showing playlist: my_cool_playlist" in lines[1]
+    assert "No videos here yet" in lines[2]
+    assert "Added video to my_cool_playlist: Amazing Cats" in lines[3]
+    assert "Showing playlist: my_COOL_playlist" in lines[4]
+    assert "Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[5]
+
+
+def test_remove_from_playlist_then_re_add(capfd):
+    player = VideoPlayer()
+    player.create_playlist("MY_playlist")
+    player.add_to_playlist("my_playlist", "amazing_cats_video_id")
+    player.add_to_playlist("my_playlist", "life_at_google_video_id")
+    player.remove_from_playlist("my_playlist", "amazing_cats_video_id")
+    player.add_to_playlist("my_playlist", "amazing_cats_video_id")
+    player.show_playlist("my_playLIST")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 8
+    assert "Showing playlist: my_playLIST" in lines[5]
+    assert "Life at Google (life_at_google_video_id) [#google #career]" in lines[6]
+    assert "Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[7]
+
+
+def test_show_playlist_nonexistent_playlist(capfd):
+    player = VideoPlayer()
+    player.show_playlist("another_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot show playlist another_playlist: Playlist does not exist" in lines[0]
+
+
+def test_remove_from_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    player.remove_from_playlist("my_COOL_playlist", "amazing_cats_video_id")
+    player.remove_from_playlist("my_cool_playlist", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 4
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Added video to my_cool_playlist: Amazing Cats" in lines[1]
+    assert "Removed video from my_COOL_playlist: Amazing Cats" in lines[2]
+    assert "Cannot remove video from my_cool_playlist: Video is not in playlist" in lines[3]
+
+
+def test_remove_from_playlist_video_is_not_in_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.remove_from_playlist("my_cool_playlist", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Cannot remove video from my_cool_playlist: Video is not in playlist" in lines[1]
+
+
+def test_remove_from_playlist_nonexistent_video(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    player.remove_from_playlist("my_cool_playlist", "some_other_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Added video to my_cool_playlist: Amazing Cats" in lines[1]
+    assert "Cannot remove video from my_cool_playlist: Video does not exist" in lines[2]
+
+
+def test_remove_from_playlist_nonexistent_playlist(capfd):
+    player = VideoPlayer()
+    player.remove_from_playlist("my_cool_playlist", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot remove video from my_cool_playlist: Playlist does not exist" in lines[0]
+
+
+def test_clear_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    player.show_playlist("my_cool_playlist")
+    player.clear_playlist("my_COOL_playlist")
+    player.show_playlist("my_cool_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 7
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Added video to my_cool_playlist: Amazing Cats" in lines[1]
+    assert "Showing playlist: my_cool_playlist" in lines[2]
+    assert "Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[3]
+    assert "Successfully removed all videos from my_COOL_playlist" in lines[4]
+    assert "Showing playlist: my_cool_playlist" in lines[5]
+    assert "No videos here yet" in lines[6]
+
+
+def test_clear_playlist_nonexistent(capfd):
+    player = VideoPlayer()
+    player.clear_playlist("my_cool_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot clear playlist my_cool_playlist: Playlist does not exist" in lines[0]
+
+
+def test_delete_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.delete_playlist("my_cool_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Deleted playlist: my_cool_playlist" in lines[1]
+
+
+def test_delete_playlist_nonexistent(capfd):
+    player = VideoPlayer()
+    player.delete_playlist("my_cool_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot delete playlist my_cool_playlist: Playlist does not exist" in lines[0]
diff --git a/solutions/python/solution1/test/part3_test.py b/solutions/python/solution1/test/part3_test.py
new file mode 100644
index 0000000..817dce3
--- /dev/null
+++ b/solutions/python/solution1/test/part3_test.py
@@ -0,0 +1,142 @@
+from src.video_player import VideoPlayer
+from unittest import mock
+
+
+@mock.patch('builtins.input', lambda *args: 'No')
+def test_search_videos_with_no_answer(capfd):
+    player = VideoPlayer()
+    player.search_videos("cat")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Here are the results for cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert (
+               "If your answer is not a valid number, we will assume "
+               "it's a no.") in lines[4]
+    assert "Playing video" not in out
+
+
+@mock.patch('builtins.input', lambda *args: '2')
+def test_search_videos_and_play_answer(capfd):
+    player = VideoPlayer()
+    player.search_videos("cat")
+
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 6
+    assert "Here are the results for cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+    assert "Playing video: Another Cat Video" in lines[5]
+
+
+@mock.patch('builtins.input', lambda *args: '6')
+def test_search_videos_number_out_of_bounds(capfd):
+    player = VideoPlayer()
+    player.search_videos("cat")
+
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Here are the results for cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+    assert "Playing video" not in out
+
+
+@mock.patch('builtins.input', lambda *args: 'ab3g')
+def test_search_videos_invalid_number(capfd):
+    player = VideoPlayer()
+    player.search_videos("cat")
+
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Here are the results for cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+    assert "Playing video" not in out
+
+
+def test_search_videos_no_results(capfd):
+    player = VideoPlayer()
+    player.search_videos("blah")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "No search results for blah" in lines[0]
+
+
+@mock.patch('builtins.input', lambda *args: 'No')
+def test_search_videos_with_tag_no_answer(capfd):
+    player = VideoPlayer()
+    player.search_videos_tag("#cat")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Here are the results for #cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+
+
+@mock.patch('builtins.input', lambda *args: '1')
+def test_search_videos_with_tag_play_answered_number(capfd):
+    player = VideoPlayer()
+    player.search_videos_tag("#cat")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 6
+    assert "Here are the results for #cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+    assert "Playing video: Amazing Cats" in lines[5]
+
+
+@mock.patch('builtins.input', lambda *args: '5')
+def test_search_videos_with_tag_number_out_of_bounds(capfd):
+    player = VideoPlayer()
+    player.search_videos_tag("#cat")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Here are the results for #cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+    assert "Playing video" not in out
+
+
+def test_search_videos_tag_no_results(capfd):
+    player = VideoPlayer()
+    player.search_videos_tag("#blah")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "No search results for #blah" in lines[0]
diff --git a/solutions/python/solution1/test/part4_test.py b/solutions/python/solution1/test/part4_test.py
new file mode 100644
index 0000000..381a48d
--- /dev/null
+++ b/solutions/python/solution1/test/part4_test.py
@@ -0,0 +1,271 @@
+from unittest import mock
+
+from src.video_player import VideoPlayer
+
+
+def test_flag_video_with_reason(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Successfully flagged video: Amazing Cats (reason: dont_like_cats)" \
+           in lines[0]
+
+
+def test_flag_video_without_reason(capfd):
+    player = VideoPlayer()
+    player.flag_video("another_cat_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Successfully flagged video: Another Cat Video " \
+           "(reason: Not supplied)" in lines[0]
+
+
+def test_flag_video_already_flagged(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully flagged video: Amazing Cats (reason: dont_like_cats)" in \
+           lines[0]
+    assert "Cannot flag video: Video is already flagged" in lines[1]
+
+
+def test_flag_video_nonexistent(capfd):
+    player = VideoPlayer()
+    player.flag_video("video_does_not_exist", "flag_video_reason")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot flag video: Video does not exist" in lines[0]
+
+
+def test_flag_video_can_no_longer_play(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id")
+    player.play_video("amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: Not supplied)" in lines[0]
+    assert "Cannot play video: Video is currently flagged " \
+           "(reason: Not supplied)" in lines[1]
+
+
+def test_flag_videos_play_random(capfd):
+    player = VideoPlayer()
+    player.flag_video("funny_dogs_video_id")
+    player.flag_video("amazing_cats_video_id")
+    player.flag_video("another_cat_video_id")
+    player.flag_video("life_at_google_video_id")
+    player.flag_video("nothing_video_id")
+    player.play_random_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 6
+    assert "Successfully flagged video: Funny Dogs " \
+           "(reason: Not supplied)" in lines[0]
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: Not supplied)" in lines[1]
+    assert "Successfully flagged video: Another Cat Video " \
+           "(reason: Not supplied)" in lines[2]
+    assert "Successfully flagged video: Life at Google " \
+           "(reason: Not supplied)" in lines[3]
+    assert "Successfully flagged video: Video about nothing " \
+           "(reason: Not supplied)" in lines[4]
+    assert "No videos available" in lines[5]
+
+
+def test_flag_video_add_to_playlist(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id")
+    player.create_playlist("my_playlist")
+    player.add_to_playlist("my_playlist", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert ("Successfully flagged video: Amazing Cats "
+            "(reason: Not supplied)") in lines[0]
+    assert "Successfully created new playlist: my_playlist" in lines[1]
+    assert ("Cannot add video to my_playlist: Video is currently "
+            "flagged (reason: Not supplied)") in lines[2]
+
+
+def test_flag_video_show_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_playlist")
+    player.add_to_playlist("my_playlist", "amazing_cats_video_id")
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.show_playlist("my_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Successfully created new playlist: my_playlist" in lines[0]
+    assert "Added video to my_playlist: Amazing Cats" in lines[1]
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[2]
+    assert "Showing playlist: my_playlist" in lines[3]
+    assert ("Amazing Cats (amazing_cats_video_id) [#cat #animal] - FLAGGED "
+            "(reason: dont_like_cats)") in lines[4]
+
+
+def test_flag_video_show_all_videos(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.show_all_videos()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 7
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[0]
+    assert "Here's a list of all available videos:" in lines[1]
+    assert ("Amazing Cats (amazing_cats_video_id) [#cat #animal] - FLAGGED "
+            "(reason: dont_like_cats)") in lines[2]
+    assert "Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[3]
+    assert "Funny Dogs (funny_dogs_video_id) [#dog #animal]" in lines[4]
+    assert "Life at Google (life_at_google_video_id) [#google #career]" in \
+           lines[5]
+    assert "Video about nothing (nothing_video_id) []" in lines[6]
+
+
+@mock.patch('builtins.input', lambda *args: 'No')
+def test_flag_video_search_videos(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.search_videos("cat")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[0]
+    assert "Here are the results for cat:" in lines[1]
+    assert "1) Another Cat Video (another_cat_video_id) [#cat #animal]" in \
+           lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+
+
+@mock.patch('builtins.input', lambda *args: 'No')
+def test_flag_video_search_videos_with_tag(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.search_videos_tag("#cat")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[0]
+    assert "Here are the results for #cat:" in lines[1]
+    assert "1) Another Cat Video (another_cat_video_id) [#cat #animal]" in \
+           lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+
+
+def test_flag_video_stops_playing_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 4
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Stopping video: Amazing Cats" in lines[1]
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[2]
+    assert "No video is currently playing" in lines[3]
+
+
+def test_flag_video_leaves_video_if_video_is_different(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.flag_video("another_cat_video_id", "dont_like_cats")
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Successfully flagged video: Another Cat Video " \
+           "(reason: dont_like_cats)" in lines[1]
+    assert "Currently playing: Amazing Cats (amazing_cats_video_id) " \
+           "[#cat #animal]" in lines[2]
+
+
+def test_flag_video_stops_paused_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.pause_video()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Pausing video: Amazing Cats" in lines[1]
+    assert "Stopping video: Amazing Cats" in lines[2]
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[3]
+    assert "No video is currently playing" in lines[4]
+
+
+def test_allow_video(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.allow_video("amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[0]
+    assert "Successfully removed flag from video: Amazing Cats" in lines[1]
+
+
+def test_allow_video_not_flagged(capfd):
+    player = VideoPlayer()
+    player.allow_video("amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot remove flag from video: Video is not flagged" in lines[0]
+
+
+def test_allow_video_nonexistent(capfd):
+    player = VideoPlayer()
+    player.allow_video("video_does_not_exist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot remove flag from video: Video does not exist" in lines[0]
+
+
+def test_allow_video_show_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_playlist")
+    player.add_to_playlist("my_playlist", "amazing_cats_video_id")
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.show_playlist("my_playlist")
+    player.allow_video("amazing_cats_video_id")
+    player.show_playlist("my_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 8
+    assert "Successfully created new playlist: my_playlist" in lines[0]
+    assert "Added video to my_playlist: Amazing Cats" in lines[1]
+    assert ("Successfully flagged video: Amazing Cats "
+            "(reason: dont_like_cats)") in lines[2]
+    assert "Showing playlist: my_playlist" in lines[3]
+    assert ("Amazing Cats (amazing_cats_video_id) [#cat #animal] - FLAGGED "
+            "(reason: dont_like_cats)") in lines[4]
+    assert "Successfully removed flag from video: Amazing Cats" in lines[5]
+    assert "Showing playlist: my_playlist" in lines[6]
+    assert "Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[7]
diff --git a/solutions/python/solution1/test/videolibrary_test.py b/solutions/python/solution1/test/videolibrary_test.py
new file mode 100644
index 0000000..7496742
--- /dev/null
+++ b/solutions/python/solution1/test/videolibrary_test.py
@@ -0,0 +1,26 @@
+from src.video_library import VideoLibrary
+
+
+def test_library_has_all_videos():
+    library = VideoLibrary()
+    assert len(library.get_all_videos()) == 5
+
+
+def test_parses_tags_correctly():
+    library = VideoLibrary()
+    video = library.get_video("amazing_cats_video_id")
+
+    assert video is not None
+    assert video.title == "Amazing Cats"
+    assert video.video_id == "amazing_cats_video_id"
+    assert set(video.tags) == {"#cat", "#animal"}
+
+
+def test_parses_video_correctly_without_tags():
+    library = VideoLibrary()
+    video = library.get_video("nothing_video_id")
+
+    assert video is not None
+    assert video.title == "Video about nothing"
+    assert video.video_id == "nothing_video_id"
+    assert video.tags == ()
diff --git a/solutions/python/solution5/README.md b/solutions/python/solution5/README.md
new file mode 100644
index 0000000..d259b4a
--- /dev/null
+++ b/solutions/python/solution5/README.md
@@ -0,0 +1,72 @@
+# Youtube Challenge - Python
+The Python Youtube Challenge uses Python3. 
+The below commands use Python3 specifically, to account for users that might 
+have Python2 installed alongside Python3.
+
+NOTE: **Please do not edit videos.txt as it will cause tests to break. There is no need to modify this file to complete this challenge.**
+
+## Installing Python and pytest
+[This guide](https://realpython.com/installing-python/) explains how to check if you already
+have Python installed, and if not, how to install it on your machine.
+Please make sure you install Python 3.7 or higher.
+
+The tests are using `pytest`, if you don't have `pytest` installed yet, you can do so by running:
+```shell script
+python3 -m pip install pytest
+```
+
+pip should be installed already if you installed Python from the official source. If not, you
+can find many guides online on how to install pip for your operating system.
+
+## Setting up
+You can write code in any editor you'd like. However, different editors have 
+different ways of dealing with Python code, so in case of doubt we recommend 
+you run the code and tests from the command line as shown  below.
+
+## Running and testing from the Commandline
+To run the command-line application:
+```shell script
+python3 -m src.run
+```
+
+You can close the app by typing `EXIT` as a command.
+
+#### Running the tests
+To run all the tests:
+```shell script
+python3 -m pytest
+```
+For more verbose test output you can use
+```shell script
+python3 -m pytest -v
+```
+
+```shell script
+python3 -m pytest test/part1_test.py
+python3 -m pytest test/part2_test.py
+python3 -m pytest test/part3_test.py
+python3 -m pytest test/part4_test.py
+```
+
+For more information on pytest commandline options, such as only running a specific test,
+you can read more [here](https://docs.pytest.org/en/6.2.x/usage.html#).
+
+## Running and testing from IntelliJ/PyCharm
+* Mark both the `python/` and `src/` directory as Sources Root
+    * (Right-click on src/ > Mark Directory As > Sources Root )
+* Mark the  `test/` directory as Test Sources Root
+    * (Right-click on test/ > Mark Directory As > Test Sources Root)
+
+This will allow your editor to correctly index the project.
+
+To run the Application, create a new "Run/Debug configuration":
+* Run > Edit Configurations > "+" Button > Python
+![intellij_setup](intellij_setup.png)
+
+To run the tests, add a pytest configuration as follows:
+* Run > Edit Configurations > "+" Button > Python tests > pytest
+
+![intellij_test_setup](intellij_test_setup.png)
+
+Then you will be able to run and debug the unit tests.
+
diff --git a/solutions/python/solution5/intellij_setup.png b/solutions/python/solution5/intellij_setup.png
new file mode 100644
index 0000000..8d99b11
Binary files /dev/null and b/solutions/python/solution5/intellij_setup.png differ
diff --git a/solutions/python/solution5/intellij_test_setup.png b/solutions/python/solution5/intellij_test_setup.png
new file mode 100644
index 0000000..788cb45
Binary files /dev/null and b/solutions/python/solution5/intellij_test_setup.png differ
diff --git a/solutions/python/solution5/src/__init__.py b/solutions/python/solution5/src/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/solutions/python/solution5/src/command_parser.py b/solutions/python/solution5/src/command_parser.py
new file mode 100644
index 0000000..dc59a46
--- /dev/null
+++ b/solutions/python/solution5/src/command_parser.py
@@ -0,0 +1,163 @@
+"""A command parser class."""
+
+import textwrap
+from typing import Sequence
+
+
+class CommandException(Exception):
+    """A class used to represent a wrong command exception."""
+    pass
+
+
+class CommandParser:
+    """A class used to parse and execute a user Command."""
+
+    def __init__(self, video_player):
+        self._player = video_player
+
+    def execute_command(self, command: Sequence[str]):
+        """Executes the user command. Expects the command to be upper case.
+           Raises CommandException if a command cannot be parsed.
+        """
+        if not command:
+            raise CommandException(
+                "Please enter a valid command, "
+                "type HELP for a list of available commands.")
+
+        if command[0].upper() == "NUMBER_OF_VIDEOS":
+            self._player.number_of_videos()
+
+        elif command[0].upper() == "SHOW_ALL_VIDEOS":
+            self._player.show_all_videos()
+
+        elif command[0].upper() == "PLAY":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter PLAY command followed by video_id.")
+            self._player.play_video(command[1])
+
+        elif command[0].upper() == "PLAY_RANDOM":
+            self._player.play_random_video()
+
+        elif command[0].upper() == "STOP":
+            self._player.stop_video()
+
+        elif command[0].upper() == "PAUSE":
+            self._player.pause_video()
+
+        elif command[0].upper() == "CONTINUE":
+            self._player.continue_video()
+
+        elif command[0].upper() == "SHOW_PLAYING":
+            self._player.show_playing()
+
+        elif command[0].upper() == "CREATE_PLAYLIST":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter CREATE_PLAYLIST command followed by a "
+                    "playlist name.")
+            self._player.create_playlist(command[1])
+
+        elif command[0].upper() == "ADD_TO_PLAYLIST":
+            if len(command) != 3:
+                raise CommandException(
+                    "Please enter ADD_TO_PLAYLIST command followed by a "
+                    "playlist name and video_id to add.")
+            self._player.add_to_playlist(command[1], command[2])
+
+        elif command[0].upper() == "REMOVE_FROM_PLAYLIST":
+            if len(command) != 3:
+                raise CommandException(
+                    "Please enter REMOVE_FROM_PLAYLIST command followed by a "
+                    "playlist name and video_id to remove.")
+            self._player.remove_from_playlist(command[1], command[2])
+
+        elif command[0].upper() == "CLEAR_PLAYLIST":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter CLEAR_PLAYLIST command followed by a "
+                    "playlist name.")
+            self._player.clear_playlist(command[1])
+
+        elif command[0].upper() == "DELETE_PLAYLIST":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter DELETE_PLAYLIST command followed by a "
+                    "playlist name.")
+            self._player.delete_playlist(command[1])
+
+        elif command[0].upper() == "SHOW_PLAYLIST":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter SHOW_PLAYLIST command followed by a "
+                    "playlist name.")
+            self._player.show_playlist(command[1])
+
+        elif command[0].upper() == "SHOW_ALL_PLAYLISTS":
+            self._player.show_all_playlists()
+
+        elif command[0].upper() == "SEARCH_VIDEOS":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter SEARCH_VIDEOS command followed by a "
+                    "search term.")
+            self._player.search_videos(command[1])
+
+        elif command[0].upper() == "SEARCH_VIDEOS_WITH_TAG":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter SEARCH_VIDEOS_WITH_TAG command followed by a "
+                    "video tag.")
+            self._player.search_videos_tag(command[1])
+
+        elif command[0].upper() == "FLAG_VIDEO":
+            if len(command) == 3:
+                self._player.flag_video(command[1], command[2])
+            elif len(command) == 2:
+                self._player.flag_video(command[1])
+            else:
+                raise CommandException(
+                    "Please enter FLAG_VIDEO command followed by a "
+                    "video_id and an optional flag reason.")
+
+        elif command[0].upper() == "ALLOW_VIDEO":
+            if len(command) != 2:
+                raise CommandException(
+                    "Please enter ALLOW_VIDEO command followed by a "
+                    "video_id.")
+            self._player.allow_video(command[1])
+
+        elif command[0].upper() == "HELP":
+            self._get_help()
+        else:
+            print(
+                "Please enter a valid command, type HELP for a list of "
+                "available commands.")
+
+    def _get_help(self):
+        """Displays all available commands to the user."""
+        help_text = textwrap.dedent("""
+        Available commands:
+            NUMBER_OF_VIDEOS - Shows how many videos are in the library.
+            SHOW_ALL_VIDEOS - Lists all videos from the library.
+            PLAY <video_id> - Plays specified video.
+            PLAY_RANDOM - Plays a random video from the library.
+            STOP - Stop the current video.
+            PAUSE - Pause the current video.
+            CONTINUE - Resume the current paused video.
+            SHOW_PLAYING - Displays the title, url and paused status of the video that is currently playing (or paused).
+            CREATE_PLAYLIST <playlist_name> - Creates a new (empty) playlist with the provided name.
+            ADD_TO_PLAYLIST <playlist_name> <video_id> - Adds the requested video to the playlist.
+            REMOVE_FROM_PLAYLIST <playlist_name> <video_id> - Removes the specified video from the specified playlist
+            CLEAR_PLAYLIST <playlist_name> - Removes all the videos from the playlist.
+            DELETE_PLAYLIST <playlist_name> - Deletes the playlist.
+            SHOW_PLAYLIST <playlist_name> - List all the videos in this playlist.
+            SHOW_ALL_PLAYLISTS - Display all the available playlists.
+            SEARCH_VIDEOS <search_term> - Display all the videos whose titles contain the search_term.
+            SEARCH_VIDEOS_WITH_TAG <tag_name> -Display all videos whose tags contains the provided tag.
+            FLAG_VIDEO <video_id> <flag_reason> - Mark a video as flagged.
+            ALLOW_VIDEO <video_id> - Removes a flag from a video.
+            HELP - Displays help.
+            EXIT - Terminates the program execution.
+        """)
+        print(help_text)
diff --git a/solutions/python/solution5/src/run.py b/solutions/python/solution5/src/run.py
new file mode 100644
index 0000000..dbb22c0
--- /dev/null
+++ b/solutions/python/solution5/src/run.py
@@ -0,0 +1,21 @@
+"""A youtube terminal simulator."""
+from .video_player import VideoPlayer
+from .command_parser import CommandException
+from .command_parser import CommandParser
+
+
+if __name__ == "__main__":
+    print("""Hello and welcome to YouTube, what would you like to do?
+    Enter HELP for list of available commands or EXIT to terminate.""")
+    video_player = VideoPlayer()
+    parser = CommandParser(video_player)
+    while True:
+        command = input("YT> ")
+        if command.upper() == "EXIT":
+            break
+        try:
+            parser.execute_command(command.split())
+        except CommandException as e:
+            print(e)
+    print("YouTube has now terminated its execution. "
+          "Thank you and goodbye!")
diff --git a/solutions/python/solution5/src/video.py b/solutions/python/solution5/src/video.py
new file mode 100644
index 0000000..59b6f48
--- /dev/null
+++ b/solutions/python/solution5/src/video.py
@@ -0,0 +1,36 @@
+"""A video class."""
+
+from typing import Sequence
+
+
+class Video:
+    """A class used to represent a Video."""
+
+    def __init__(self, video_title: str, video_id: str, video_tags: Sequence[str]):
+        """Video constructor."""
+        self._title = video_title
+        self._video_id = video_id
+
+        # Turn the tags into a tuple here so it's unmodifiable,
+        # in case the caller changes the 'video_tags' they passed to us
+        self._tags = tuple(video_tags)
+
+    def __str__(self) -> str:
+        """Returns string representation of a video."""
+        tags = " ".join(self.tags)
+        return f"{self.title} ({self.video_id}) [{tags}]"
+
+    @property
+    def title(self) -> str:
+        """Returns the title of a video."""
+        return self._title
+
+    @property
+    def video_id(self) -> str:
+        """Returns the video id of a video."""
+        return self._video_id
+
+    @property
+    def tags(self) -> Sequence[str]:
+        """Returns the list of tags of a video."""
+        return self._tags
diff --git a/solutions/python/solution5/src/video_library.py b/solutions/python/solution5/src/video_library.py
new file mode 100644
index 0000000..57140e6
--- /dev/null
+++ b/solutions/python/solution5/src/video_library.py
@@ -0,0 +1,45 @@
+"""A video library class."""
+
+from .video import Video
+from pathlib import Path
+import csv
+
+
+# Helper Wrapper around CSV reader to strip whitespace from around
+# each item.
+def _csv_reader_with_strip(reader):
+    yield from ((item.strip() for item in line) for line in reader)
+
+
+class VideoLibrary:
+    """A class used to represent a Video Library."""
+
+    def __init__(self):
+        """The VideoLibrary class is initialized."""
+        self._videos = {}
+        with open(Path(__file__).parent / "videos.txt") as video_file:
+            reader = _csv_reader_with_strip(
+                csv.reader(video_file, delimiter="|"))
+            for video_info in reader:
+                title, url, tags = video_info
+                self._videos[url] = Video(
+                    title,
+                    url,
+                    [tag.strip() for tag in tags.split(",")] if tags else [],
+                )
+
+    def get_all_videos(self):
+        """Returns all available video information from the video library."""
+        return list(self._videos.values())
+
+    def get_video(self, video_id):
+        """Returns the video object (title, url, tags) from the video library.
+
+        Args:
+            video_id: The video url.
+
+        Returns:
+            The Video object for the requested video_id. None if the video
+            does not exist.
+        """
+        return self._videos.get(video_id, None)
diff --git a/solutions/python/solution5/src/video_player.py b/solutions/python/solution5/src/video_player.py
new file mode 100644
index 0000000..3c0d81b
--- /dev/null
+++ b/solutions/python/solution5/src/video_player.py
@@ -0,0 +1,352 @@
+"""A video player class."""
+
+from random import choice
+from typing import Optional
+from .video import Video
+from .video_library import VideoLibrary
+from .video_playlist import Playlist
+
+
+class VideoPlayer:
+    """A class used to represent a Video Player."""
+
+    def __init__(self) -> None:
+        self._library: VideoLibrary = VideoLibrary()
+        self._current: Optional[Video] = None
+        self._paused: bool = False
+        self._playlists: dict[str, Playlist] = {}
+        self._flags: dict[str, str] = {}
+
+    def number_of_videos(self) -> None:
+        num_videos = len(self._library.get_all_videos())
+        print(f"{num_videos} videos in the library")
+
+    def show_all_videos(self) -> None:
+        """Returns all videos."""
+        print("Here's a list of all available videos:")
+
+        videos = self._get_sorted_videos()
+        self._print_videos(videos)
+
+    def play_video(self, video_id: str) -> None:
+        """Plays the respective video.
+
+        Args:
+            video_id: The video_id to be played.
+        """
+        video = self._library.get_video(video_id)
+        if video is None:
+            print("Cannot play video: Video does not exist")
+            return
+
+        flag_reason = self._flags.get(video_id, "")
+        if flag_reason:
+            print(f"Cannot play video: "
+                  f"Video is currently flagged (reason: {flag_reason})")
+            return
+
+        if self._current is not None:
+            print(f"Stopping video: {self._current.title}")
+
+        print(f"Playing video: {video.title}")
+        self._current = video
+        self._paused = False
+
+    def stop_video(self) -> None:
+        """Stops the current video."""
+        if self._current is None:
+            print("Cannot stop video: No video is currently playing")
+            return
+
+        print(f"Stopping video: {self._current.title}")
+        self._current = None
+        self._paused = False
+
+    def play_random_video(self) -> None:
+        """Plays a random video from the video library."""
+        videos = self._filter_flagged_videos(self._library.get_all_videos())
+        if not videos:
+            print("No videos available")
+            return
+
+        video = choice(videos)
+        self.play_video(video.video_id)
+
+    def pause_video(self) -> None:
+        """Pauses the current video."""
+        if self._current is None:
+            print("Cannot pause video: No video is currently playing")
+            return
+
+        if self._paused:
+            print(f"Video already paused: {self._current.title}")
+            return
+
+        print(f"Pausing video: {self._current.title}")
+        self._paused = True
+
+    def continue_video(self) -> None:
+        """Resumes playing the current video."""
+        if self._current is None:
+            print("Cannot continue video: No video is currently playing")
+            return
+
+        if not self._paused:
+            print("Cannot continue video: Video is not paused")
+            return
+
+        print(f"Continuing video: {self._current.title}")
+        self._paused = False
+
+    def show_playing(self) -> None:
+        """Displays video currently playing."""
+        if self._current is None:
+            print("No video is currently playing")
+            return
+
+        if self._paused:
+            print(f"Currently playing: {self._current} - PAUSED")
+        else:
+            print(f"Currently playing: {self._current}")
+
+    def create_playlist(self, playlist_name: str) -> None:
+        """Creates a playlist with a given name.
+
+        Args:
+            playlist_name: The playlist name.
+        """
+        if playlist_name.lower() in self._playlists:
+            print("Cannot create playlist: "
+                  "A playlist with the same name already exists")
+            return
+
+        self._playlists[playlist_name.lower()] = Playlist(playlist_name)
+        print(f"Successfully created new playlist: {playlist_name}")
+
+    def add_to_playlist(self, playlist_name: str, video_id: str) -> None:
+        """Adds a video to a playlist with a given name.
+
+        Args:
+            playlist_name: The playlist name.
+            video_id: The video_id to be added.
+        """
+        playlist = self._playlists.get(playlist_name.lower(), None)
+        if playlist is None:
+            print(f"Cannot add video to {playlist_name}: "
+                  f"Playlist does not exist")
+            return
+
+        video = self._library.get_video(video_id)
+        if video is None:
+            print(f"Cannot add video to {playlist_name}: Video does not exist")
+            return
+
+        flag_reason = self._flags.get(video_id, "")
+        if flag_reason:
+            print(f"Cannot add video to {playlist_name}: "
+                  f"Video is currently flagged (reason: {flag_reason})")
+            return
+
+        if video in playlist:
+            print(f"Cannot add video to {playlist_name}: Video already added")
+            return
+
+        playlist.add(video)
+        print(f"Added video to {playlist_name}: {video.title}")
+
+    def show_all_playlists(self) -> None:
+        """Display all playlists."""
+        if not self._playlists:
+            print("No playlists exist yet")
+            return
+
+        playlists = sorted(self._playlists.values(), key=lambda p: p.name)
+
+        print("Showing all playlists:")
+        for playlist in playlists:
+            print(f"  {playlist}")
+
+    def show_playlist(self, playlist_name: str) -> None:
+        """Display all videos in a playlist with a given name.
+
+        Args:
+            playlist_name: The playlist name.
+        """
+        playlist = self._playlists.get(playlist_name.lower(), None)
+        if playlist is None:
+            print(f"Cannot show playlist {playlist_name}: "
+                  f"Playlist does not exist")
+            return
+
+        print(f"Showing playlist: {playlist_name}")
+
+        videos = playlist.get_all_videos()
+        if not videos:
+            print("  No videos here yet")
+            return
+
+        self._print_videos(videos)
+
+
+    def remove_from_playlist(self, playlist_name: str, video_id: str) -> None:
+        """Removes a video to a playlist with a given name.
+
+        Args:
+            playlist_name: The playlist name.
+            video_id: The video_id to be removed.
+        """
+        playlist = self._playlists.get(playlist_name.lower(), None)
+        if playlist is None:
+            print(f"Cannot remove video from {playlist_name}: "
+                  f"Playlist does not exist")
+            return
+
+        video = self._library.get_video(video_id)
+        if video is None:
+            print(f"Cannot remove video from {playlist_name}: "
+                  f"Video does not exist")
+            return
+
+        if video not in playlist:
+            print(f"Cannot remove video from {playlist_name}: "
+                  f"Video is not in playlist")
+            return
+
+        playlist.remove(video)
+        print(f"Removed video from {playlist_name}: {video.title}")
+
+    def clear_playlist(self, playlist_name: str) -> None:
+        """Removes all videos from a playlist with a given name.
+
+        Args:
+            playlist_name: The playlist name.
+        """
+        playlist = self._playlists.get(playlist_name.lower(), None)
+        if playlist is None:
+            print(f"Cannot clear playlist {playlist_name}: "
+                  f"Playlist does not exist")
+            return
+
+        self._playlists[playlist_name.lower()] = Playlist(playlist.name)
+        print(f"Successfully removed all videos from {playlist_name}")
+
+    def delete_playlist(self, playlist_name: str) -> None:
+        """Deletes a playlist with a given name.
+
+        Args:
+            playlist_name: The playlist name.
+        """
+        playlist = self._playlists.get(playlist_name.lower(), None)
+        if playlist is None:
+            print(f"Cannot delete playlist {playlist_name}: "
+                  f"Playlist does not exist")
+            return
+
+        del self._playlists[playlist_name.lower()]
+        print(f"Deleted playlist: {playlist_name}")
+
+    def search_videos(self, search_term: str) -> None:
+        """Display all the videos whose titles contain the search_term.
+
+        Args:
+            search_term: The query to be used in search.
+        """
+        videos = self._get_sorted_videos()
+        videos = [v for v in videos if search_term.lower() in v.title.lower()]
+
+        self._print_search_results(search_term, videos)
+
+    def search_videos_tag(self, video_tag: str) -> None:
+        """Display all videos whose tags contains the provided tag.
+
+        Args:
+            video_tag: The video tag to be used in search.
+        """
+        videos = self._get_sorted_videos()
+        videos = [v for v in videos if video_tag.lower() in v.tags]
+
+        self._print_search_results(video_tag, videos)
+
+    def flag_video(self, video_id: str, flag_reason: str = "") -> None:
+        """Mark a video as flagged.
+
+        Args:
+            video_id: The video_id to be flagged.
+            flag_reason: Reason for flagging the video.
+        """
+        if video_id in self._flags:
+            print("Cannot flag video: Video is already flagged")
+            return
+
+        video = self._library.get_video(video_id)
+        if video is None:
+            print("Cannot flag video: Video does not exist")
+            return
+
+        if video is self._current:
+            self.stop_video()
+
+        if not flag_reason:
+            flag_reason = "Not supplied"
+
+        self._flags[video_id] = flag_reason
+        print(f"Successfully flagged video: {video.title} "
+              f"(reason: {flag_reason})")
+
+    def allow_video(self, video_id: str) -> None:
+        """Removes a flag from a video.
+
+        Args:
+            video_id: The video_id to be allowed again.
+        """
+        video = self._library.get_video(video_id)
+        if video is None:
+            print("Cannot remove flag from video: Video does not exist")
+            return
+
+        if video_id not in self._flags:
+            print("Cannot remove flag from video: Video is not flagged")
+            return
+
+        del self._flags[video_id]
+        print(f"Successfully removed flag from video: {video.title}")
+
+    def _filter_flagged_videos(self, videos: list[Video]) -> list[Video]:
+        return [v for v in videos if v.video_id not in self._flags]
+
+    def _get_sorted_videos(self) -> list[Video]:
+        return sorted(self._library.get_all_videos(), key=lambda v: v.title)
+
+    def _print_search_results(self, search: str, videos: list[Video]) -> None:
+        """Prints search results and suggests to play a video."""
+        videos = self._filter_flagged_videos(videos)
+
+        if not videos:
+            print(f"No search results for {search}")
+            return
+
+        print(f"Here are the results for {search}:")
+        for idx, video in enumerate(videos, start=1):
+            print(f"  {idx}) {video}")
+
+        print("Would you like to play any of the above? "
+              "If yes, specify the number of the video. ")
+        print("If your answer is not a valid number, we will assume it's a no.")
+
+        try:
+            idx = int(input())
+            if idx < 1 or idx > len(videos):
+                raise ValueError()
+        except ValueError:
+            return
+
+        self.play_video(videos[idx - 1].video_id)
+
+    def _print_videos(self, videos: list[Video]) -> None:
+        """Prints a list of videos."""
+        for video in videos:
+            flag_reason = self._flags.get(video.video_id, "")
+            if flag_reason:
+                print(f"  {video} - FLAGGED (reason: {flag_reason})")
+            else:
+                print(f"  {video}")
diff --git a/solutions/python/solution5/src/video_playlist.py b/solutions/python/solution5/src/video_playlist.py
new file mode 100644
index 0000000..cf83b02
--- /dev/null
+++ b/solutions/python/solution5/src/video_playlist.py
@@ -0,0 +1,37 @@
+"""A video playlist class."""
+
+from .video import Video
+
+
+class Playlist:
+    """A class used to represent a Playlist."""
+
+    def __init__(self, name: str) -> None:
+        """Initializes a playlist."""
+        self._name: str = name
+        self._videos: dict[str, Video] = {}
+
+    def __str__(self) -> str:
+        """Returns a string representation of a playlist."""
+        return f"{self._name} ({len(self._videos)} videos)"
+
+    def __contains__(self, video: Video) -> bool:
+        """Checks whether the given video is contained within a playlist."""
+        return video.video_id in self._videos
+
+    @property
+    def name(self) -> str:
+        """Returns a name of a playlist."""
+        return self._name
+
+    def add(self, video: Video) -> None:
+        """Adds the given video to a playlist."""
+        self._videos[video.video_id] = video
+
+    def remove(self, video: Video) -> None:
+        """Removes the given video from a playlist."""
+        self._videos.pop(video.video_id, None)
+
+    def get_all_videos(self) -> list[Video]:
+        """Returns a list of all videos from this playlist."""
+        return list(self._videos.values())
diff --git a/solutions/python/solution5/src/videos.txt b/solutions/python/solution5/src/videos.txt
new file mode 100644
index 0000000..0800bb7
--- /dev/null
+++ b/solutions/python/solution5/src/videos.txt
@@ -0,0 +1,5 @@
+Funny Dogs | funny_dogs_video_id |  #dog , #animal
+Amazing Cats | amazing_cats_video_id |  #cat , #animal
+Another Cat Video | another_cat_video_id |  #cat , #animal
+Life at Google | life_at_google_video_id |  #google , #career
+Video about nothing | nothing_video_id |
\ No newline at end of file
diff --git a/solutions/python/solution5/test/part1_test.py b/solutions/python/solution5/test/part1_test.py
new file mode 100644
index 0000000..b2568a6
--- /dev/null
+++ b/solutions/python/solution5/test/part1_test.py
@@ -0,0 +1,238 @@
+import re
+from src.video_player import VideoPlayer
+
+
+def test_number_of_videos(capfd):
+    player = VideoPlayer()
+    player.number_of_videos()
+    out, err = capfd.readouterr()
+    assert "5 videos in the library" in out
+
+
+def test_show_all_videos(capfd):
+    player = VideoPlayer()
+    player.show_all_videos()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 6
+    assert "Here's a list of all available videos:" in lines[0]
+    assert "Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert "Funny Dogs (funny_dogs_video_id) [#dog #animal]" in lines[3]
+    assert "Life at Google (life_at_google_video_id) [#google #career]" in lines[4]
+    assert "Video about nothing (nothing_video_id) []" in lines[5]
+
+
+def test_play_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Playing video: Amazing Cats" in out
+
+
+def test_play_video_nonexistent(capfd):
+    player = VideoPlayer()
+    player.play_video("does_not_exist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot play video: Video does not exist" in out
+
+
+def test_play_video_stop_previous(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.play_video("funny_dogs_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Stopping video: Amazing Cats" in lines[1]
+    assert "Playing video: Funny Dogs" in lines[2]
+
+
+def test_play_video_dont_stop_previous_if_nonexistent(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.play_video("some_other_video")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Stopping video: Amazing Cats" not in out
+    assert "Cannot play video: Video does not exist" in lines[1]
+
+
+def test_stop_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.stop_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Stopping video: Amazing Cats" in lines[1]
+
+
+def test_stop_video_twice(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.stop_video()
+    player.stop_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Stopping video: Amazing Cats" in lines[1]
+    assert "Cannot stop video: No video is currently playing" in lines[2]
+
+
+def test_stop_video_none_playing(capfd):
+    player = VideoPlayer()
+    player.stop_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot stop video: No video is currently playing" in out
+
+
+def test_play_random_video(capfd):
+    player = VideoPlayer()
+    player.play_random_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert re.match(
+        "Playing video: (Amazing Cats|Another Cat Video|Funny Dogs|Life at Google|Video about nothing)",
+        out)
+
+
+def test_play_random_stops_previous_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.play_random_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Stopping video: Amazing Cats" in lines[1]
+    assert re.match(
+        "Playing video: (Amazing Cats|Another Cat Video|Funny Dogs|Life at Google|Video about nothing)",
+        lines[2])
+
+
+def test_show_playing(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Currently playing: Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+
+
+def test_show_nothing_playing(capfd):
+    player = VideoPlayer()
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "No video is currently playing" in lines[0]
+
+
+def test_pause_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.pause_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Pausing video: Amazing Cats" in lines[1]
+
+
+def test_pause_video_show_playing(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.pause_video()
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Currently playing: Amazing Cats (amazing_cats_video_id) " \
+           "[#cat #animal] - PAUSED" in lines[2]
+
+
+def test_pause_video_play_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.pause_video()
+    player.play_video("amazing_cats_video_id")
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Pausing video: Amazing Cats" in lines[1]
+    assert "Stopping video: Amazing Cats" in lines[2]
+    assert "Playing video: Amazing Cats" in lines[3]
+    assert "Currently playing: Amazing Cats (amazing_cats_video_id) " \
+           "[#cat #animal]" in lines[4]
+    assert "PAUSED" not in lines[4]
+
+
+def test_pause_already_paused_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.pause_video()
+    player.pause_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Pausing video: Amazing Cats" in lines[1]
+    assert "Video already paused: Amazing Cats" in lines[2]
+
+
+def test_pause_video_none_playing(capfd):
+    player = VideoPlayer()
+    player.pause_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot pause video: No video is currently playing" in lines[0]
+
+
+def test_continue_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.pause_video()
+    player.continue_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Pausing video: Amazing Cats" in lines[1]
+    assert "Continuing video: Amazing Cats" in lines[2]
+
+
+def test_continue_video_not_paused(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.continue_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Cannot continue video: Video is not paused" in lines[1]
+
+
+def test_continue_none_playing(capfd):
+    player = VideoPlayer()
+    player.continue_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot continue video: No video is currently playing" in lines[0]
diff --git a/solutions/python/solution5/test/part2_test.py b/solutions/python/solution5/test/part2_test.py
new file mode 100644
index 0000000..99ff02a
--- /dev/null
+++ b/solutions/python/solution5/test/part2_test.py
@@ -0,0 +1,237 @@
+from src.video_player import VideoPlayer
+
+
+def test_create_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_PLAYlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Successfully created new playlist: my_PLAYlist" in lines[0]
+
+
+def test_create_existing_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.create_playlist("my_COOL_PLAYLIST")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert ("Cannot create playlist: A playlist with the same name already "
+            "exists") in lines[1]
+
+
+def test_add_to_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_COOL_playlist")
+    player.add_to_playlist("my_cool_PLAYLIST", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully created new playlist: my_COOL_playlist" in lines[0]
+    assert "Added video to my_cool_PLAYLIST: Amazing Cats" in lines[1]
+
+
+def test_add_to_playlist_already_added(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Added video to my_cool_playlist: Amazing Cats" in lines[1]
+    assert "Cannot add video to my_cool_playlist: Video already added" in lines[2]
+
+
+def test_add_to_playlist_nonexistent_video(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    player.add_to_playlist("my_cool_playlist", "some_other_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Added video to my_cool_playlist: Amazing Cats" in lines[1]
+    assert "Cannot add video to my_cool_playlist: Video does not exist" in lines[2]
+
+
+def test_add_to_playlist_nonexistent_playlist(capfd):
+    player = VideoPlayer()
+    player.add_to_playlist("another_playlist", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot add video to another_playlist: Playlist does not exist" in lines[0]
+
+
+def test_add_to_playlist_nonexistent_playlist_nonexistent_video(capfd):
+    player = VideoPlayer()
+    player.add_to_playlist("another_playlist", "does_not_exist_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot add video to another_playlist: Playlist does not exist" in lines[0]
+
+
+def test_show_all_playlists_no_playlists_exist(capfd):
+    player = VideoPlayer()
+    player.show_all_playlists()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "No playlists exist yet" in lines[0]
+
+
+def test_show_all_playlists(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playLIST")
+    player.create_playlist("anotheR_playlist")
+    player.show_all_playlists()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Showing all playlists:" in lines[2]
+    assert "anotheR_playlist" in lines[3]
+    assert "my_cool_playLIST" in lines[4]
+
+
+def test_show_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.show_playlist("my_cool_playlist")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    player.show_playlist("my_COOL_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 6
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Showing playlist: my_cool_playlist" in lines[1]
+    assert "No videos here yet" in lines[2]
+    assert "Added video to my_cool_playlist: Amazing Cats" in lines[3]
+    assert "Showing playlist: my_COOL_playlist" in lines[4]
+    assert "Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[5]
+
+
+def test_remove_from_playlist_then_re_add(capfd):
+    player = VideoPlayer()
+    player.create_playlist("MY_playlist")
+    player.add_to_playlist("my_playlist", "amazing_cats_video_id")
+    player.add_to_playlist("my_playlist", "life_at_google_video_id")
+    player.remove_from_playlist("my_playlist", "amazing_cats_video_id")
+    player.add_to_playlist("my_playlist", "amazing_cats_video_id")
+    player.show_playlist("my_playLIST")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 8
+    assert "Showing playlist: my_playLIST" in lines[5]
+    assert "Life at Google (life_at_google_video_id) [#google #career]" in lines[6]
+    assert "Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[7]
+
+
+def test_show_playlist_nonexistent_playlist(capfd):
+    player = VideoPlayer()
+    player.show_playlist("another_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot show playlist another_playlist: Playlist does not exist" in lines[0]
+
+
+def test_remove_from_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    player.remove_from_playlist("my_COOL_playlist", "amazing_cats_video_id")
+    player.remove_from_playlist("my_cool_playlist", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 4
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Added video to my_cool_playlist: Amazing Cats" in lines[1]
+    assert "Removed video from my_COOL_playlist: Amazing Cats" in lines[2]
+    assert "Cannot remove video from my_cool_playlist: Video is not in playlist" in lines[3]
+
+
+def test_remove_from_playlist_video_is_not_in_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.remove_from_playlist("my_cool_playlist", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Cannot remove video from my_cool_playlist: Video is not in playlist" in lines[1]
+
+
+def test_remove_from_playlist_nonexistent_video(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    player.remove_from_playlist("my_cool_playlist", "some_other_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Added video to my_cool_playlist: Amazing Cats" in lines[1]
+    assert "Cannot remove video from my_cool_playlist: Video does not exist" in lines[2]
+
+
+def test_remove_from_playlist_nonexistent_playlist(capfd):
+    player = VideoPlayer()
+    player.remove_from_playlist("my_cool_playlist", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot remove video from my_cool_playlist: Playlist does not exist" in lines[0]
+
+
+def test_clear_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.add_to_playlist("my_cool_playlist", "amazing_cats_video_id")
+    player.show_playlist("my_cool_playlist")
+    player.clear_playlist("my_COOL_playlist")
+    player.show_playlist("my_cool_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 7
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Added video to my_cool_playlist: Amazing Cats" in lines[1]
+    assert "Showing playlist: my_cool_playlist" in lines[2]
+    assert "Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[3]
+    assert "Successfully removed all videos from my_COOL_playlist" in lines[4]
+    assert "Showing playlist: my_cool_playlist" in lines[5]
+    assert "No videos here yet" in lines[6]
+
+
+def test_clear_playlist_nonexistent(capfd):
+    player = VideoPlayer()
+    player.clear_playlist("my_cool_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot clear playlist my_cool_playlist: Playlist does not exist" in lines[0]
+
+
+def test_delete_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_cool_playlist")
+    player.delete_playlist("my_cool_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully created new playlist: my_cool_playlist" in lines[0]
+    assert "Deleted playlist: my_cool_playlist" in lines[1]
+
+
+def test_delete_playlist_nonexistent(capfd):
+    player = VideoPlayer()
+    player.delete_playlist("my_cool_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot delete playlist my_cool_playlist: Playlist does not exist" in lines[0]
diff --git a/solutions/python/solution5/test/part3_test.py b/solutions/python/solution5/test/part3_test.py
new file mode 100644
index 0000000..817dce3
--- /dev/null
+++ b/solutions/python/solution5/test/part3_test.py
@@ -0,0 +1,142 @@
+from src.video_player import VideoPlayer
+from unittest import mock
+
+
+@mock.patch('builtins.input', lambda *args: 'No')
+def test_search_videos_with_no_answer(capfd):
+    player = VideoPlayer()
+    player.search_videos("cat")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Here are the results for cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert (
+               "If your answer is not a valid number, we will assume "
+               "it's a no.") in lines[4]
+    assert "Playing video" not in out
+
+
+@mock.patch('builtins.input', lambda *args: '2')
+def test_search_videos_and_play_answer(capfd):
+    player = VideoPlayer()
+    player.search_videos("cat")
+
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 6
+    assert "Here are the results for cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+    assert "Playing video: Another Cat Video" in lines[5]
+
+
+@mock.patch('builtins.input', lambda *args: '6')
+def test_search_videos_number_out_of_bounds(capfd):
+    player = VideoPlayer()
+    player.search_videos("cat")
+
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Here are the results for cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+    assert "Playing video" not in out
+
+
+@mock.patch('builtins.input', lambda *args: 'ab3g')
+def test_search_videos_invalid_number(capfd):
+    player = VideoPlayer()
+    player.search_videos("cat")
+
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Here are the results for cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+    assert "Playing video" not in out
+
+
+def test_search_videos_no_results(capfd):
+    player = VideoPlayer()
+    player.search_videos("blah")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "No search results for blah" in lines[0]
+
+
+@mock.patch('builtins.input', lambda *args: 'No')
+def test_search_videos_with_tag_no_answer(capfd):
+    player = VideoPlayer()
+    player.search_videos_tag("#cat")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Here are the results for #cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+
+
+@mock.patch('builtins.input', lambda *args: '1')
+def test_search_videos_with_tag_play_answered_number(capfd):
+    player = VideoPlayer()
+    player.search_videos_tag("#cat")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 6
+    assert "Here are the results for #cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+    assert "Playing video: Amazing Cats" in lines[5]
+
+
+@mock.patch('builtins.input', lambda *args: '5')
+def test_search_videos_with_tag_number_out_of_bounds(capfd):
+    player = VideoPlayer()
+    player.search_videos_tag("#cat")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Here are the results for #cat:" in lines[0]
+    assert "1) Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[1]
+    assert "2) Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+    assert "Playing video" not in out
+
+
+def test_search_videos_tag_no_results(capfd):
+    player = VideoPlayer()
+    player.search_videos_tag("#blah")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "No search results for #blah" in lines[0]
diff --git a/solutions/python/solution5/test/part4_test.py b/solutions/python/solution5/test/part4_test.py
new file mode 100644
index 0000000..381a48d
--- /dev/null
+++ b/solutions/python/solution5/test/part4_test.py
@@ -0,0 +1,271 @@
+from unittest import mock
+
+from src.video_player import VideoPlayer
+
+
+def test_flag_video_with_reason(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Successfully flagged video: Amazing Cats (reason: dont_like_cats)" \
+           in lines[0]
+
+
+def test_flag_video_without_reason(capfd):
+    player = VideoPlayer()
+    player.flag_video("another_cat_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Successfully flagged video: Another Cat Video " \
+           "(reason: Not supplied)" in lines[0]
+
+
+def test_flag_video_already_flagged(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully flagged video: Amazing Cats (reason: dont_like_cats)" in \
+           lines[0]
+    assert "Cannot flag video: Video is already flagged" in lines[1]
+
+
+def test_flag_video_nonexistent(capfd):
+    player = VideoPlayer()
+    player.flag_video("video_does_not_exist", "flag_video_reason")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot flag video: Video does not exist" in lines[0]
+
+
+def test_flag_video_can_no_longer_play(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id")
+    player.play_video("amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: Not supplied)" in lines[0]
+    assert "Cannot play video: Video is currently flagged " \
+           "(reason: Not supplied)" in lines[1]
+
+
+def test_flag_videos_play_random(capfd):
+    player = VideoPlayer()
+    player.flag_video("funny_dogs_video_id")
+    player.flag_video("amazing_cats_video_id")
+    player.flag_video("another_cat_video_id")
+    player.flag_video("life_at_google_video_id")
+    player.flag_video("nothing_video_id")
+    player.play_random_video()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 6
+    assert "Successfully flagged video: Funny Dogs " \
+           "(reason: Not supplied)" in lines[0]
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: Not supplied)" in lines[1]
+    assert "Successfully flagged video: Another Cat Video " \
+           "(reason: Not supplied)" in lines[2]
+    assert "Successfully flagged video: Life at Google " \
+           "(reason: Not supplied)" in lines[3]
+    assert "Successfully flagged video: Video about nothing " \
+           "(reason: Not supplied)" in lines[4]
+    assert "No videos available" in lines[5]
+
+
+def test_flag_video_add_to_playlist(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id")
+    player.create_playlist("my_playlist")
+    player.add_to_playlist("my_playlist", "amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert ("Successfully flagged video: Amazing Cats "
+            "(reason: Not supplied)") in lines[0]
+    assert "Successfully created new playlist: my_playlist" in lines[1]
+    assert ("Cannot add video to my_playlist: Video is currently "
+            "flagged (reason: Not supplied)") in lines[2]
+
+
+def test_flag_video_show_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_playlist")
+    player.add_to_playlist("my_playlist", "amazing_cats_video_id")
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.show_playlist("my_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Successfully created new playlist: my_playlist" in lines[0]
+    assert "Added video to my_playlist: Amazing Cats" in lines[1]
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[2]
+    assert "Showing playlist: my_playlist" in lines[3]
+    assert ("Amazing Cats (amazing_cats_video_id) [#cat #animal] - FLAGGED "
+            "(reason: dont_like_cats)") in lines[4]
+
+
+def test_flag_video_show_all_videos(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.show_all_videos()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 7
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[0]
+    assert "Here's a list of all available videos:" in lines[1]
+    assert ("Amazing Cats (amazing_cats_video_id) [#cat #animal] - FLAGGED "
+            "(reason: dont_like_cats)") in lines[2]
+    assert "Another Cat Video (another_cat_video_id) [#cat #animal]" in lines[3]
+    assert "Funny Dogs (funny_dogs_video_id) [#dog #animal]" in lines[4]
+    assert "Life at Google (life_at_google_video_id) [#google #career]" in \
+           lines[5]
+    assert "Video about nothing (nothing_video_id) []" in lines[6]
+
+
+@mock.patch('builtins.input', lambda *args: 'No')
+def test_flag_video_search_videos(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.search_videos("cat")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[0]
+    assert "Here are the results for cat:" in lines[1]
+    assert "1) Another Cat Video (another_cat_video_id) [#cat #animal]" in \
+           lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+
+
+@mock.patch('builtins.input', lambda *args: 'No')
+def test_flag_video_search_videos_with_tag(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.search_videos_tag("#cat")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[0]
+    assert "Here are the results for #cat:" in lines[1]
+    assert "1) Another Cat Video (another_cat_video_id) [#cat #animal]" in \
+           lines[2]
+    assert ("Would you like to play any of the above? If yes, "
+            "specify the number of the video.") in lines[3]
+    assert ("If your answer is not a valid number, we will assume "
+            "it's a no.") in lines[4]
+
+
+def test_flag_video_stops_playing_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 4
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Stopping video: Amazing Cats" in lines[1]
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[2]
+    assert "No video is currently playing" in lines[3]
+
+
+def test_flag_video_leaves_video_if_video_is_different(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.flag_video("another_cat_video_id", "dont_like_cats")
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 3
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Successfully flagged video: Another Cat Video " \
+           "(reason: dont_like_cats)" in lines[1]
+    assert "Currently playing: Amazing Cats (amazing_cats_video_id) " \
+           "[#cat #animal]" in lines[2]
+
+
+def test_flag_video_stops_paused_video(capfd):
+    player = VideoPlayer()
+    player.play_video("amazing_cats_video_id")
+    player.pause_video()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.show_playing()
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 5
+    assert "Playing video: Amazing Cats" in lines[0]
+    assert "Pausing video: Amazing Cats" in lines[1]
+    assert "Stopping video: Amazing Cats" in lines[2]
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[3]
+    assert "No video is currently playing" in lines[4]
+
+
+def test_allow_video(capfd):
+    player = VideoPlayer()
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.allow_video("amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 2
+    assert "Successfully flagged video: Amazing Cats " \
+           "(reason: dont_like_cats)" in lines[0]
+    assert "Successfully removed flag from video: Amazing Cats" in lines[1]
+
+
+def test_allow_video_not_flagged(capfd):
+    player = VideoPlayer()
+    player.allow_video("amazing_cats_video_id")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot remove flag from video: Video is not flagged" in lines[0]
+
+
+def test_allow_video_nonexistent(capfd):
+    player = VideoPlayer()
+    player.allow_video("video_does_not_exist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 1
+    assert "Cannot remove flag from video: Video does not exist" in lines[0]
+
+
+def test_allow_video_show_playlist(capfd):
+    player = VideoPlayer()
+    player.create_playlist("my_playlist")
+    player.add_to_playlist("my_playlist", "amazing_cats_video_id")
+    player.flag_video("amazing_cats_video_id", "dont_like_cats")
+    player.show_playlist("my_playlist")
+    player.allow_video("amazing_cats_video_id")
+    player.show_playlist("my_playlist")
+    out, err = capfd.readouterr()
+    lines = out.splitlines()
+    assert len(lines) == 8
+    assert "Successfully created new playlist: my_playlist" in lines[0]
+    assert "Added video to my_playlist: Amazing Cats" in lines[1]
+    assert ("Successfully flagged video: Amazing Cats "
+            "(reason: dont_like_cats)") in lines[2]
+    assert "Showing playlist: my_playlist" in lines[3]
+    assert ("Amazing Cats (amazing_cats_video_id) [#cat #animal] - FLAGGED "
+            "(reason: dont_like_cats)") in lines[4]
+    assert "Successfully removed flag from video: Amazing Cats" in lines[5]
+    assert "Showing playlist: my_playlist" in lines[6]
+    assert "Amazing Cats (amazing_cats_video_id) [#cat #animal]" in lines[7]
diff --git a/solutions/python/solution5/test/videolibrary_test.py b/solutions/python/solution5/test/videolibrary_test.py
new file mode 100644
index 0000000..7496742
--- /dev/null
+++ b/solutions/python/solution5/test/videolibrary_test.py
@@ -0,0 +1,26 @@
+from src.video_library import VideoLibrary
+
+
+def test_library_has_all_videos():
+    library = VideoLibrary()
+    assert len(library.get_all_videos()) == 5
+
+
+def test_parses_tags_correctly():
+    library = VideoLibrary()
+    video = library.get_video("amazing_cats_video_id")
+
+    assert video is not None
+    assert video.title == "Amazing Cats"
+    assert video.video_id == "amazing_cats_video_id"
+    assert set(video.tags) == {"#cat", "#animal"}
+
+
+def test_parses_video_correctly_without_tags():
+    library = VideoLibrary()
+    video = library.get_video("nothing_video_id")
+
+    assert video is not None
+    assert video.title == "Video about nothing"
+    assert video.video_id == "nothing_video_id"
+    assert video.tags == ()