PCPP2 study plan

Write unittest test cases with setUp, tearDown, and assertRaises for a small module and run them with python -m unittest

Convert the same test suite to pytest using plain assert statements, fixtures, and parametrize

Measure coverage with coverage.py and identify at least three uncovered branches in your own code

Explain the difference between a mock, a stub, and a spy and apply unittest.mock.patch to isolate an external call

Apply test-driven development to build a small class by writing failing tests first, then minimal code, then refactor

Write tests for exceptions, edge cases, and slow operations using pytest.raises, pytest.mark.skip, and pytest.mark.parametrize

Implement the Singleton pattern in three ways (module-level instance, new, metaclass) and write tests proving only one instance exists

Implement the Factory pattern and test that the factory returns the correct concrete class for each input key

Implement the Facade pattern to wrap a multi-step subsystem behind a single simplified interface and test it with mocks

Implement the Proxy pattern for lazy loading and access control, and test both the allowed and denied paths

Implement the Observer pattern with a subject that notifies registered callbacks and test notification order and unsubscribe behavior

Compare the Command and Template Method patterns by coding one example of each and documenting when each is preferable

Implement the State pattern as a state machine with explicit transitions and test every legal transition plus one illegal one

Create a thread with threading.Thread, run work in it, and join it correctly without blocking the main thread prematurely

Protect shared state with threading.Lock and demonstrate a race condition before the lock and its absence after

Use concurrent.futures.ThreadPoolExecutor and ProcessPoolExecutor and explain when each is appropriate for CPU-bound versus IO-bound work

Start processes with multiprocessing.Process and exchange data through Queue and Pipe

Share state safely with multiprocessing.Value, Array, and Lock, and explain why plain globals fail across processes

Use multiprocessing.Pool.map and apply_async to parallelize a CPU-bound task and compare timing to a serial run

Launch external commands with subprocess.run, capture stdout and stderr, check return codes, and handle timeouts

Explain and demonstrate the difference between subprocess.Popen, run, and check_output, including shell=True risks

Build a TCP echo server and client with the socket module and handle multiple clients using threads

Explain the difference between blocking and non-blocking sockets and demonstrate selectors for multiplexing

Create a UDP sender and receiver and contrast connectionless behavior with TCP

Use socket timeouts and handle ConnectionResetError and socket.timeout gracefully

Parse and construct IPv4 and IPv6 addresses with the ipaddress module and validate network membership

Explain how software-defined networking separates the control plane from the data plane and describe the role of a controller and OpenFlow-style flow rules

Apply TLS to a socket connection with ssl.SSLContext and verify certificates

Identify common network security weaknesses (unvalidated input, plaintext credentials, missing timeouts) and harden the week 6 server against them

Perform CRUD operations against SQLite with the sqlite3 module using parameterized queries and transactions

Model a schema with an ORM such as SQLAlchemy, define relationships, and query with filters and joins

Perform CRUD against a NoSQL store such as MongoDB or a document-style store and compare its data model to a relational one

Write tests that use an in-memory database fixture so the suite runs without external services

Review weak areas across all five domains and re-run every earlier deliverable's tests