Overview This assignment provides practical experience developing a Java project based on a supplied speciication.  The speciication is provided in the form of JavaDocs, which describe the classes and interfaces that your program must implement.  Additionally, you must write JUnit tests for a subset of these classes.

You will be evaluated on your ability to;

❼ implement a program that complies with the speciication,

❼ write JUnit tests that can identify errors in class implementations,

❼ and write code that conforms to the style conventions of the course.

Task Spreadsheet applications are powerful tools that combine data and formulae to perform calculations. In this assignment, you will be implementing SheeP (Sheet Processor), a spread- sheet application.  SheeP is similar to Microsoft Excel or Google Sheets, it consists of a grid of cells each of which contains either data or a formula. The formulae can reference other cells in the grid to use their values. Formulae are evaluated to produce a value for the cell. A cell is updated whenever the data or formulae in any cell it references changes.

Common Mistakes Please carefully read Appendix A. It outlines common and critical mistakes which you must avoid to prevent a loss of marks.  If at any point you are even slightly unsure, please check as soon as possible with course staf.

Project Overview

sheep.core This package provides the interface between the model of a spreadsheet and the user interface.

Implementations of the SheetView interface tell the interface how it should render a spread- sheet and communicate this information via the ViewElement object.

Implementations of the SheetUpdate interface process user updates to the spreadsheet and provide the result of the update via a UpdateResponse object.

sheep.sheets This package contains implementations of the SheetView and SheetUpdate inter- faces and other supporting classes.  Primarily it implements three diferent types of spread- sheets: FixedSheet, DisplaySheet, and Sheet.

sheep.expression Within a spreadsheet, the value at a particular cell is represented by an expres-

sion. This package stores the Expression abstract class that all expressions must extend.

Expressions are built via expression factories which implement the ExpressionFactory in- terface, e.g. CoreFactory.

This package also stores relevant exceptions.

sheep.expression.basic This package storescore expression implementations, namely, the empty cell, Nothing, a constant number value, Constant, and a reference to another cell, Reference.

sheep.expression.arithmetic Arithmetic expressions are contained in this package.  All arith- metic expressions are subclasses of the base abstract class Arithmetic.

sheep.parsing A parser accepts string input and builds an appropriate expression. For example, given the string “4”, a  parser  would  build  an  instance of the  Constant expression that represents 4.

All  parsers  must  implement  the  Parser  interface.   If  a  parser  cannot  parse  a  string,  a

ParseException is thrown.

sheep.fun Provided classes that pre-populate spreadsheets with test data, such as the Fibonacci sequence using the Fibonacci class.

sheep.ui Provided implementation of a user interface.

Stages

The assignment is split into stages to encourage incremental development.  You should complete each stage before moving on to the next .  The provided Main class allows you to run each stage individually by uncommenting the appropriate lines in the main method.  Figure 1 highlights the classes that you will implement in each stage:  green for stage 0, blue for stage 1, yellow for stage 2, and purple for provided code.  At each stage, ensure that you thoroughly test your implementation.

Stage 0 Create a simple implementation of a spreadsheet, FixedSheet.  The FixedSheet class should be within the sheep.sheets package and implement the sheep.core.SheetView and sheep.core.SheepUpdate interfaces. After implementing the FixedSheet class and un- commenting the appropriate lines in the main method, the program should run as below.

Stage 1 Implement just the basic types of expressions within the spreadsheet:  constant values, references to other cells, and empty cells.  Create an expression factory to create these expressions and a parser to parse expressions from strings.  Finally create DisplaySheet to show the results of these expressions.  When the appropriate lines in the main method are commented out, the program should run as below.

Stage 2 Complete the implementation of expressions to include arithmetic operations. Your parser and expression factory should be able to parse and create these expressions.  Create the full Sheet implementation, this sheet should appropriately update cells when other cells change.  When the appropriate lines in the main method are commented out, the program should run as below.

where n is the number of faulty solutions.

See Appendix B for more details.

Ensure that your classes and interfaces correctly declare the package they are within.  For example, Reference.java should declare package  sheep.expression.basic;.

Do not submit any other iles (e.g. no  .class iles).

Note that CellLocationTest and ReferenceTest  will be compiled individually against a sample solution without the rest of your test iles.

Provided tests A small number of the unit tests (about 10-20%) used for assessing Functional- ity (F) are provided in Gradescope, which can be used to test your submission against.  In addition, a small number of the JUnit faulty solutions used for assessing JUnit tests (T) are also provided in Gradescope.

The purpose of this is to provide you with an opportunity to receive feedback on whether the basic functionality of your classes and tests is correct or not.  Passing all the provided unit tests does not guarantee that you will pass all the tests used for functionality marking.

Assessment Policy

Late Submission Any submission made after the grace period (of one hour) will not be marked. Your last submission before the deadline will be marked.

Do not wait until the last minute to submit the inal version of your assignment.  A submission that starts before 13:00 but inishes after 13:00 will not be marked.

Extensions If an unavoidable disruption occurs  (e.g.   illness,  family crisis,  etc.)   you should consider applying for an extension. Please refer to the following page for further information:

https://uq.mu/rl551

All requests for extensions must be made via my.UQ. Do not email your course coordinator or the demonstrators to request an extension.

Remarking If an administrative error has been made in the marking of your assignment (e.g. marks were incorrectly added up), please contact the course coordinator ([email protected]) to request this be ixed.

For all other cases, please refer to the following page for further information:

https://uq.mu/rl552

Change Log                                                                                                         Revision:  1.2.1

v1.2.1

JavaDocs

A    Critical Mistakes

THINGS YOU MUST AVOID

This is being heavily emphasised here because these are critical mistakes which must be avoided.

Code may run ine locally on your own computer in IntelliJ, but it is required that it also builds and runs correctly when it is marked with the electronic marking tool in Gradescope. Your solution needs to conform to the speciication for this to occur.

❼ Files must be in the correct directories  (exactly)  as speciied by the Javadoc.  If iles are in incorrect directories (even slightly wrong), you may lose marks for functionality in these iles because the implementation does not conform to the speciication.

❼ Files must have the exact correct package declaration at the top of the ile.   If iles have incorrect package declarations (even slightly wrong), you may lose marks for functionality in these iles because the implementation does not conform to the speciication.

❼ You must implement the public and protected members exactly as described in the supplied documentation (no extra public/protected members or classes ). Creating public or protected data members in a class when it is not speciied will result in loss of marks, because the implementation does not conform to the speciication.

。You are encouraged to create private members as you see it to implement the required functionality or improve the design of your solution.

❼ Never import the org.junit.jupiter.api package.  This is from JUnit 5.  This will cause the JUnit tests to fail, resulting in no marks for the JUnit component.

❼ Do not use any version of Java newer than 21 when writing your solution.  If you accidentally use Java features which are only present in a version newer than 21, then your submission may fail to compile.

B    JUnit Test Marking

The JUnit tests you write for a class (e.g.  CellLocationTest.java) are evaluated by checking whether they can distinguish between a:

correct implementation of the respective class

e.g. CellLocation.java, made by the teaching staf, and

incorrect implementations of the respective class

“deliberately made  (sabotaged)  by  the  teaching staf ”.

First, we run your unit tests (e.g.  CellLocationTest.java) against the correct implementation of the respective classes (e.g. CellLocation.java).

We look at how many unit tests you have, and how many have passed.  Let us imagine that you have 7 unit tests in CellLocationTest.java   and 4 unit tests in ReferenceTest.java, and they all pass (i.e. none result in Assert.fail() in JUnit4).

We will then run your unit tests in both classes (CellLocationTest.java, ReferenceTest.java) against an incorrect implementation of the respective class (e.g. CellLocation.java). For exam- ple, the foo() method in the CellLocation.java ile is incorrect.

We then look at how many of your unit tests pass.