Oregon State CS 362: Software Engineering II
CS 362 is the verification half of the software engineering sequence: unit testing, test-driven development, coverage, debugging strategy, and continuous integration. It's the course that converts testing from the thing skipped before deadlines into an engineering discipline.
Fennie is independent and not affiliated with Oregon State University. This is an unofficial study guide.
What makes it hard
Testing well is harder than it sounds: choosing what to test, constructing edge cases, and judging coverage requires adversarial thinking about your own code, which is an unnatural act that needs deliberate practice. The conceptual material (coverage criteria, test design techniques) is also exactly the kind of detail where proctored exams reward precision and punish vibes.
What you'll cover
- • Unit testing frameworks
- • Test-driven development
- • Code coverage and test adequacy
- • Debugging strategies
- • Continuous integration
- • Random and property-based testing
The CS 362 study guide
How to study for Oregon State CS 362, step by step.
- 1
Write tests for code you didn't write
Testing your own code inherits your own blind spots. Practice on others' functions; it builds the adversarial eye the course is actually trying to install.
- 2
Learn the coverage criteria precisely
Statement, branch, and path coverage differ in exam-relevant ways, and the questions are built on the differences. Know what each criterion catches and what it provably misses.
- 3
Do TDD honestly at least once
Test first, fail, implement, pass: the full cycle on a small project, without cheating the order. The exam questions about TDD assume you've felt the rhythm rather than only read about it.
- 4
Hunt edge cases as a drill
Empty inputs, boundaries, duplicates, overflow: build a personal checklist and run it against every function you meet. Edge-case construction is the course's most exam-visible skill.
Today's CS 362 plan
What a Fennie Daily Plan looks like for CS 362. Yours is built from your syllabus and adapts every day to your deadlines and progress.
- Review: Continuous integrationReview · 25 min
Work back through the CS 362 material on continuous integration. In the app, Fennie builds this from your own notes and syllabus.
- Practice: Random and property-based testingPractice · 20 min
Targeted problems on random and property-based testing, the kind CS 362 actually tests.
- Quick quiz: Unit testing frameworksQuiz · 10 min
Five generated questions to expose weak spots on unit testing frameworks before the exam does.
- Preview: Test-driven developmentPreview · 10 min
A first pass over test-driven development so the next session starts from familiar ground.
First plan free, no card required. Fennie is independent and unaffiliated with your school.
FAQ
Is CS 362 easier than CS 361?
Most postbacc students find it less logistically stressful (smaller-scale teamwork, more individual skill-building) but conceptually denser. The coverage and test-design material rewards exact understanding, which makes it more exam-driven than 361.
What testing tools does CS 362 use?
Expect a mainstream unit-testing framework and CI tooling, with specifics varying by term and language. The principles (test design, coverage, TDD discipline) transfer across all of them, and they're what's graded.
Why does CS 362 matter for jobs?
Because writing tests is most of what junior engineers do in their first months, and interviewers increasingly probe testing instincts. The edge-case checklist and TDD habits from 362 show up directly in take-home assessments and code review.
More Oregon State courses
CS 161: Introduction to Computer Science I
CS 161 is Oregon State's first programming course: variables, control flow, functions, basic data structures, and program design, currently taught in Python after the curriculum moved away from C++. It opens both the Corvallis CS degree and the Ecampus postbacc, where for many students it's the first code they've ever written.
CS 162: Introduction to Computer Science II
CS 162 continues the intro sequence with object-oriented programming, recursion, basic data structures, and significantly larger programs, taught in Python like CS 161. It carries a reputation as the Ecampus program's first real filter: the course where assignment scope jumps and time management becomes the curriculum.
CS 225: Discrete Structures in Computer Science
CS 225 is the CS department's discrete math course, covering logic, proofs, sets, functions, combinatorics, and graphs. It's required in the Ecampus postbacc and a prerequisite mindset for CS 325. For career changers from non-quantitative fields, it's often the first proof-based math they've ever faced.
CS 261: Data Structures
CS 261 covers the core data structures (dynamic arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs) with implementation assignments and complexity analysis throughout. In the Ecampus postbacc it's taught in Python (older blog posts reference the earlier C version), and it's the technical-interview foundation for the whole program.