SOFT3202/COMP9202 Assignment
Software Construction and Design 2
Task Description
Software development relies heavily on testing and monitoring to ensure the quality, reliability and
performance of the software in production. In this assignment, you will develop a series of tools that
can be used to test and monitor software during the software development pipeline.
Assignment Breakdown
The requirements for completing this assignment are dependent on the course you are taking. The
assignment is due on the 12th of May, 2024.
SOFT3202:
Students taking SOFT3202 must complete the following sections to attain the correspond-
ing marks:
Part 1 (15%)
Select one of:
Part 2
Part 3 (15%)
Note: Students may not combine marks from Parts 2 and 3. You will only receive marks
for the higher scoring of either implementation.
COMP9202:
Students taking COMP9202 must complete the following sections to attain the correspond-
ing marks:
Part 1 (10%)
Part 2 (10%)
Part 3 (10%)
Example Submissions
SOFT3202
Examples for SOFT3202
Example 1:
Part 1: 5 marks
Part 2: 15 marks
Total marks: 20
Example 2:
Part 1: 7 marks
Part 3: 18 marks
Total marks: 25
Example 3:
Part 1: 6 marks
Part 2: 15 marks
Part 3: 18 marks
Total marks: 24
COMP9202
Examples for COMP9202
Example 1:
Part 1: 7 marks
Part 2: 8 marks
Total marks: 15
Example 2:
Part 1: 8 marks
Part 2: 7 marks
Part 3: 9 marks
Total marks: 24
Page 2
Part 1: Coverage
Introduction
This component requires the development of a comprehensive tool to analyse a provided test suite for
a piece of software. The analysis must cover two key white-box testing metrics: statement coverage
and k-path coverage. The aim is to assess the efficacy and thoroughness of the test suite in detecting
faults and ensuring robustness in the software.
Objectives
• Implement a tool that takes a series of given test inputs and runs them on a program.
• Report the statement and k-paths coverage for the program when run using the series of test
inputs.
Requirements
1. Statement Coverage
Objective: Determine the percentage of executable statements in the software that are executed by
the test cases in the test suite.
2. k-Paths Coverage
Objective: Identify and report the number of acyclic paths through the program’s control flow graph
that are covered by the test suite.
Input Specifications
Your program should take 2 command-line arguments:
1. The path to a Python script
2. The path to a directory containing a set of input (.in) files
It should be called using the following command:
python coverage.py
Output Specifications
Your program should produce output indicating:
1 Statement Coverage: The percentage of statements executed during testing.
2 k-Path Coverage: The percentage of acyclic paths executed during testing.
For example:
1 Statement Coverage: 50%
2 k-Path Coverage: 12%
Page 3
Part 2: Fuzzing with Mutated Inputs
Introduction
In this part of the assignment, you will develop a fuzzer designed to automate the generation and
mutation of test inputs to maximize the coverage of a test suite. The primary goal is to expand the test
coverage by identifying and adding inputs that expose new paths or states in the software under test.
Objectives
• Develop a fuzzer capable of generating and mutating test inputs.
• Implement a method to measure the increase in test coverage.
• Automate the process of enhancing the test suite with inputs that increase coverage.
Requirements
This task requires you to take a program along with a series of inputs and mutate the inputs to achieve
a minimum coverage. You must automatically improve the test suite by adding mutated inputs that
increase coverage.
Implementation Specifications
• Use the fuzzer to apply mutations to the initial set of inputs.
• For each mutated input, execute the test suite to determine if the mutation results in increased
coverage.
• If an input increases coverage (by reaching new code paths or conditions not previously tested),
add it to a ’population’ of effective test inputs.
• Continue this process until no further increase in coverage is observed, aiming to achieve the
largest possible coverage.
• Write the final set of test inputs that collectively provide the highest coverage observed to a file.
Input Specifications
Your program should take 2 command-line arguments:
1. The path to a Python script
2. The path to a single text (.txt) file
It should be called using the following command:
python mutation_fuzzer.py
The text file will contain a set of inputs, each on a new line.
For example:
1 Never
2 Gonna
3 Give
4 You
5 Up
Page 4
Output Specifications
Your program should write back to the provided input (.in) file with exactly the same number of
input strings as was provided initially.
For example:
1 Never
2 Gonna
3 Let
4 You
5 Down
Part 3: Grammar-Based Fuzzing
Introduction
Grammar-based fuzzing is a commonly used method to test programs that consume structured inputs,
particularly input parsers.
Objectives
• Implement a grammar-based fuzzer to generate structured inputs for testing.
• Explore various grammar structures to hit or exceed a coverage threshold.
Requirements
This task requires implementing a grammar-based fuzzer capable of generating structured inputs
based on a specified grammar. The goal is to hit or exceed a coverage threshold by generating a
test suite that effectively tests the target program.
Implementation Specifications
• Develop algorithms to interpret grammar specifications and generate inputs accordingly.
• Explore different paths and options within the grammar to maximise code coverage.
• Test the generated inputs on the target program to assess its coverage.
• Implement mechanisms to adjust the generation process to hit or exceed the coverage threshold.
Input Specifications
Your program should take 3 command-line arguments:
1. The path to a Python script
2. The path to a single Python (.py) script containing the grammar specifications using the syntax
taught in the lectures and tutorials
3. The number of strings your program should generate for the test suite
It should be called using the following command:
python grammar_fuzzer.py
The grammar file should define the structure of the inputs using a specified syntax.
Page 5
Output Specifications
The program should generate structured inputs based on the grammar specifications provided and
write them to an output file. The output file should contain the specified number of strings each on a
new line, where each string represents a test input. The generated inputs should cover various paths
and options within the grammar, aiming to hit or exceed the coverage threshold defined for the target
program.
For example, if the desired number of strings is 100:
1 input_1
2 input_2
3 ...
4 input_100
Make sure that the generated inputs cover as many grammar rules and options as possible to effectively
test the target program and meet the coverage threshold.
Getting Started
• Review Tutorials and Lectures: Begin by reviewing the tutorials and lectures. Remember
that everything you need for each component has already been covered in this unit.
• Understand the Fundamentals: Go through the revision slides on Ed and make sure that
you understand all of the content covered so far.
• Ask Questions: If you have any questions or uncertainties about the material covered, don’t
hesitate to ask on Ed for clarification and a TA will get back to you shortly.
Frequently Asked Questions
• Hard coding will result in a 0 for all tasks.
• No external libraries (i.e. those installed using pip or another package manager) may be
used - this is a limitation of Edstem.
• You have unlimited attempts before the deadline.
• There are public, private and hidden test cases for all tasks.
• Test cases will gradually be released over the coming days, and you should check Ed for
announcements.
• You may reuse their code from Quiz 1 and any other task from this unit.
• All code, even your own, must be referenced as per the university’s policy.
• You may structure your program as you wish as long as it is written in Python and gets
called using the described commands.
Page 6
Academic Declaration
By submitting this assignment, you declare the following:
I declare that I have read and understood the University of Sydney Student Plagiarism: Coursework
Policy and Procedure, and except where specifically acknowledged, the work contained in this as-
signment/project is my own work, and has not been copied from other sources or been previously
submitted for award or assessment.
I understand that failure to comply with the Student Plagiarism: Coursework Policy and Procedure
can lead to severe penalties as outlined under Chapter 8 of the University of Sydney By-Law 1999
(as amended). These penalties may be imposed in cases where any significant portion of my submit-
ted work has been copied without proper acknowledgement from other sources, including published
works, the Internet, existing programs, the work of other students, or work previously submitted for
other awards or assessments.
I realise that I may be asked to identify those portions of the work contributed by me and required to
demonstrate my knowledge of the relevant material by answering oral questions or by undertaking
supplementary work, either written or in the laboratory, in order to arrive at the final assessment
mark.
I acknowledge that the School of Computer Science, in assessing this assignment, may reproduce
it entirely, may provide a copy to another member of faculty, and/or communicate a copy of this
assignment to a plagiarism checking service or in-house computer program, and that a copy of the
assignment may be maintained by the service or the School of Computer Science for the purpose of
future plagiarism checking.
Page 7