SOFT3202: Software Construction and Design 2 Assignment: Test and Monitor Software Development
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 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 Part 2 Part 3 (10%) (10%) (10%) |
Example Submissions SOFT3202
|
Examples for SOFT3202 |
|
• Example 1: • Example 2: • Example 3: |
COMP9202
|
Examples for COMP9202 |
|
• Example 1: Part 1: 7 marks Part 2: 8 marks Total marks: 15 • Example 2: |
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 branch 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 coverage and branch coverage for the program when run using the series
of test inputs.
Requirements
1. Statement CoverageObjective: Determine the percentage of executable statements in the software that are executed by the test cases in the test suite.
2. Branch Coverage
Objective: Identify and report the number of branches through the program’s control flow graph thatare 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) filesIt should be called using the following command:
python coverage.py <python_program> <input_file_dir>Output Specifications
Your program should produce output indicating:
-
1 Statement Coverage: The count of statements executed during testing.
-
2 Branch Coverage: The count of branches executed during testing.
For example:
-
1 Statement Coverage: 50%
-
2 Branch Coverage: 50%
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 maximise the branch coverage of a test suite. The primary goal is to expand the test coverage by identifying and adding inputs that expose new branches in the software under test.
Objectives
• Develop a fuzzer capable of generating and mutating test inputs.
• Implement a method to measure the increase in branch coverage.
• Automate the process of enhancing the test suite with inputs that increase branch coverage.
Requirements
This task requires you to take a program along with a series of inputs and mutate the inputs to achieve a minimum branch coverage (note that in Part I we ask for statement coverage and branch coverage). You must automatically improve the test suite by adding mutated inputs that increase the branch 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
branch coverage.
-
If an input increases branch coverage (by reaching new conditions not previously tested), add
it to a ’population’ of effective test inputs.
-
Continuethisprocessuntilnofurtherincreaseinbranchcoverageisobserved,aimingtoachieve
the largest possible branch coverage.
-
Write the final set of test inputs that collectively provide the highest branch 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 (.in) fileIt should be called using the following command:
python mutation_fuzzer.py <python_program> <input_file>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 branch coverage threshold specified.
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 branch coverage threshold by gener- ating 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 the branch coverage.
-
Test the generated inputs on the target program to assess its branch coverage.
-
Implement mechanisms to adjust the generation process to hit or exceed the input and code
coverage threshold.
Input Specifications
Your program should take 3 command-line arguments:
-
The path to a Python script
-
ThepathtoasinglePython(.py)scriptcontainingthegrammarspecificationsusingthesyntax taught in the lectures and tutorials; the grammar will be stored as the variable ’grammar’
-
The number of strings your program should generate for the test suite
It should be called using the following command:
python grammar_fuzzer.py <python_program> <grammar_file> <num_strings>
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 branch 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 input and code 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
