CSSE2002/7023 Assignment 1

Hello, dear friend, you can consult us at any time if you have any questions, add WeChat: daixieit

CSSE2002/7023 — Semester 2, 2021

Assignment 1

Abstract

The goal of this assignment is to implement and test a set of classes and interfaces to be used in the second assignment.

Language requirements: Java version 11, JUnit 4.

Preamble

All work on this assignment is to be your own individual work. As detailed in Lecture 1, code supplied by course staff (from this semester) is acceptable, but there are no other exceptions. You are expected to be familiar with “What not to do” from Lecture 1 and https://www.itee.uq.edu.au/itee-student-misconduct-including-plagiarism. If you have questions about what is acceptable, please ask course staff.

Please carefully read the Appendix A document. It outlines critical mistakes which you must avoid in order to avoid losing marks. This is being heavily emphasised here because these are critical mistakes which must be avoided. If at any point you are even slightly unsure, please check as soon as possible with course staff!

All times are given in Australian Eastern Standard Time. It is your responsibility to ensure that you adhere to this timezone for all assignment related matters. Please bear this in mind, especially if you are enrolled in the External offering and may be located in a different time zone.

Introduction

In this assignment, and continuing into the second assignment, you will build a simple simulation of a cargo port system. The first assignment will focus on implementing the classes that provide the core model for the system.

A cargo port system manages the movement of ships around a port, including loading and unload-ing ships at quays, storing cargo at the port temporarily, and managing a queue of ships waiting offshore to dock at the port. The system also keeps track of statistics relating to the port’s opera-tions (more about this in assignment 2).

A port is made up of several quays, which are designed to accommodate specific types of ships. Ships are separated into two types: container ships and bulk carriers. Container ships carry ship-ping containers of various types, while bulk carriers are designed to hold large quantities of bulk cargo, such as grain, minerals, or oil.

Each ship has various characteristics which are known to the port system, including the ship’s name, unique International Maritime Organisation (IMO) number, country of origin, nautical flag, and cargo capacity. These characteristics determine whether the ship is able to dock at each of the port’s quays, which cargo can be loaded onto the ship, and whether the ship will be prioritised in the queue of ships waiting to dock.

The port system keeps track of all cargo that enters and exits the port. Each piece of cargo is identified by a unique identifer, and has a destination associated with it. Cargo is classified as either a shipping container or bulk cargo.

To represent the actions of ships and cargo moving into and out of the port, the port system uses Movement classes, specifically ShipMovement and CargoMovement. These movements store the direction of the movement (inbound or outbound), the time at which it is occurring and the cargo/ship that is being moved.

An inbound cargo movement represents cargo being delivered at the port by land vehicles (trains, trucks, etc.) to be loaded onto ships. An outbound cargo movement represents cargo being removed from storage at the port and picked up by land vehicles. An inbound ship movement represents a ship arriving in the waters nearby the port and wishing to dock. An outbound ship movement represents a ship departing from its quay and leaving the port.

Supplied Material

● This task sheet.

● Code specification document (Javadoc).

● Gradescope, a website where you will submit your assignment.

● A starting template for your assignment code, available for download on Blackboard. The files in this template provide a minimal framework for you to work from, and build upon. These files have been provided so that you can avoid (some of) the critical mistakes described in Appendix A. Each of these files:

– is in the correct directory (do not change this!)

– has the correct package declaration at the top of the file (do not change this!)

– has the correct public class or public interface declaration. Note that you may still need to make classes abstract, extend classes, implement interfaces etc., as detailed in the Javadoc specification.

As the first step in the assignment (after reading through the specifications) you should download the template code from Blackboard. Once you have created a new project from the files you have downloaded, you should start implementing the specification.

Javadoc

Code specifications are an important tool for developing code in collaboration with other peo-ple. Although assignments in this course are individual, they still aim to prepare you for writing code to a strict specification by providing a specification document (in Java, this is called Javadoc).

You will need to implement the specification precisely as it is described in the specification docu-ment.

The Javadoc can be viewed in either of the two following ways:

1. Open https://csse2002.uqcloud.net/assignment/1/ in your web browser. Note that this will only be the most recent version of the Javadoc.

2. Navigate to the relevant assignment folder under Assessment on Blackboard and you will be able to download the Javadoc .zip file containing HTML documentation. Unzip the bundle somewhere, and open doc/index.html with your web browser.

Tasks

1. Fully implement each of the classes and interfaces described in the Javadoc.

2. Write JUnit 4 tests for all the methods in the following classes:

● BulkCarrier (in a class called BulkCarrierTest)

● BulkCargo (in a class called BulkCargoTest)

● BulkQuay (in a class called BulkQuayTest)

Marking

The 100 marks available for the assignment will be divided as follows:

        The overall assignment mark will be A1 = F T + CF + SL + CR + JU with the following adjustments:

1. If FT is 0, then the manual code style review will not be marked. CR will be automatically 0.

2. If SL is 0, then the manual code style review will not be marked. CR will be automatically 0.

3. If SL + CR > FT, then SL + CR will be capped at a maximum of FT.

● For example: FT = 22, CF = 8, SL = 7, CR = 18, J = 13 ⇒ A1 = 22 + 8 + (7 + 18) + 13. ⇒ A1 = 22 + 8 + (25) + 13. Limitation will now be applied. ⇒ A1 = 22 + 8 + (22) + 13.

The reasoning here is to place emphasis on good quality functional code.

Well styled code that does not implement the required functionality is of no value in a project, consequently marks will not be given to well styled code that is not functional.

Functionality Marking

The number of functionality marks given will be

Conformance

Conformance is marked starting with a mark of 10.

Every single occurrence of a conformance violation in your solution then results in a 1 mark de-duction, down to a minimum of 0. Note that multiple conformance violations of the same type will each result in a 1 mark deduction.

Conformance violations include (but are not limited to):

● Placing files in incorrect directories.

● Incorrect package declarations at the top of files.

● Using modifiers on classes, methods and member variables that are different to those specified in the Javadoc. Modifiers include private, protected, public, abstract, final, and static. For example, declaring a method as public when it should be private.

● Adding extra public methods, constructors, member variables or classes that are not de-scribed in the Javadoc.

● Incorrect parameters and exceptions declared as thrown for constructors.

● Incorrect parameters, return type and exceptions declared as thrown for methods.

● Incorrect types of public fields.

Code Style

Code Structure and Layout

The Code Structure and Layout category is marked starting with a mark of 10. Every single occurrence of a style violation in your solution, as detected by CheckStyle using the course-provided configuration, results in a 0.5 mark deduction, down to a minimum of 0. Note that multiple style violations of the same type will each result in a 0.5 mark deduction.

Note: There is a plugin available for IntelliJ which will highlight style violations in your code. Instructions for installing this plugin are available in the Java Programming Style Guide on Black-board (Learning Resources → Guides). If you correctly use the plugin and follow the style require-ments, it should be relatively straightforward to get high marks for this section.

Code Review

Your assignment will be style marked with respect to the course style guide, located under Learn-ing Resources → Guides. The marks are broadly divided as follows:

Note that style marking does involve some aesthetic judgement (and the marker’s aesthetic judge-ment is final).

Note that the plugin available for IntelliJ mentioned in the Code Structure and Layout section cannot tell you whether your code violates style guidelines for this section. You will need to man-ually check your code against the style guide.

The Code Review is marked starting with a mark of 20. Penalities are then applied where appli-cable, to a minimum of 0.

JUnit Test Marking

See Appendix B for more details.

The JUnit tests that you provide in BulkCarrierTest, BulkCargoTest and BulkQuayTest will be used to test both correct and incorrect implementations of the BulkCarrier, BulkCargo and BulkQuay classes. Marks will be awarded for test sets which distinguish between correct and incorrect implementations. A test class which passes every implementation (or fails every imple-mentation) will likely get a low mark. Marks will be rewarded for tests which pass or fail correctly.

There will be some limitations on your tests:

1. If your tests take more than 20 seconds to run, or

2. If your tests consume more memory than is reasonable or are otherwise malicious, then your tests will be stopped and a mark of zero given. These limits are very generous (e.g. your tests should not take anywhere near 20 seconds to run).

Electronic Marking

The electronic aspects of the marking will be carried out in a Linux environment. The environment will not be running Windows, and neither IntelliJ nor Eclipse (or any other IDE) will be involved. OpenJDK 11 will be used to compile and execute your code and tests.

It is critical that your code compiles.

If your submission does not compile, you will receive zero for Functionality (FT).

Submission

How/Where to Submit

Submission is via Gradescope.

Instructions for submitting to Gradescope will be made available on Blackboard (under Assessment → Assignment 1) towards the start of week 4. You will not be able to submit your assignment before then.

You must ensure that you have submitted your code to Gradescope before the submission deadline. Code that is submitted after the deadline will not be marked (1 nanosecond late is still late).

You may submit your assignment to Gradescope as many times as you wish before the due date, however only your last submission made before the due date will be marked.

What to Submit

Your submission should have the following internal structure:

src/    folders (packages) and .java files for classes described in the Javadoc

test/   folders (packages) and .java files for the JUnit test classes

A complete submission would look like:

Ensure that your classes and interfaces correctly declare the package they are within. For example, Quay.java should declare package portsim.port.

Do not submit any other files (e.g. no .class files). Note that BulkCarrierTest, BulkCargoTest and BulkQuayTest will be compiled individually against a sample solution without the rest of your test files.

Provided set of unit tests

A small number of the unit tests (about 10-20%) used for assessing Functionality (FT) (not con-formance, style, or JUnit tests) will be provided in Gradescope prior to the submision deadline, which you will be able to test your submission against.

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

Instructions about the provided set of unit tests will be made available on Blackboard (under Assessment → Assignment 1) towards the start of week 4. Instructions will not be provided before then. This will still give you over two weeks to submit and check your work before the assignment is due.

Late Submission

Assignments submitted after the submission deadline of 16:00 on August 3 2021 (by any amount of time), will receive a mark of zero unless an extension is granted as outlined in the Electronic Course Profile — see the Electronic Course Profile for details.

Do not wait until the last minute to submit the final version of your assignment. A submission that starts before 16:00 but finishes after 16:00 will not be marked. Exceptions cannot be made for individual students, as this would not be fair to all other students.

Assignment Extensions

For assignment one, extensions longer than 7 calendar days will not be possible due to the depen-dency of assignment two on the work completed in assignment one. This matches what is outlined in the respective Electronic Course Profile.

All requests for extensions must be made via my.UQ as outlined in section 5.3 of the respective Electronic Course Profile. Please not directly email the course coordinator seeking an extension (you will be redirected to my.UQ).

Remark Requests

To submit a remark of this assignment please follow the information presented here: https://my.uq.edu.au/information-and-services/manage-my-program/exams-and-assessment/querying-result.

Revisions

If it becomes necessary to correct or clarify the task sheet or Javadoc, a new version will be issued and an announcement will be made on the Blackboard course site.

Appendix A: Critical Mistakes which can cause loss in marks. Things you need to avoid!

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

The way assignments are marked has been heavily revised this semester to address many of these issues where possible, but there are still issues which can only be avoided by making sure the specification is followed correctly.

Code may run fine 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 specification for this to occur.

Correctly reading specification requirements is a key objective for the course.

● Files must be in the exact correct directories specified by the Javadoc. If files are in incorrect directories (even slightly wrong), you may lose marks for functionality in these files because the implementation does not conform to the specification.

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

● 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 required will result in loss of marks, because the implementation does not conform to the specification.

– Private members may be added at your own discretion.

● Never import the org.junit.jupiter.api package. This is from JUnit 5. This will auto-matically cause the marks for the JUnit section to be 0 because JUnit 5 functionality is not supported.

● Do NOT use any version of Java newer than 11 when writing your solution! If you accidentally use Java features which are only present in a version newer than 11, then your submission may fail to compile when marked. This will automatically cause the marks for associated files with this functionality to be 0.

Appendix B: How your JUnit unit tests are marked.

The JUnit tests you write for a class (e.g. BulkCarrierTest.java) are evaluated by checking whether they can distinguish between a correct implementation of the respective class (e.g. Bulk-Carrier.java) (made by the teaching staff), and incorrect implementations of the respective class (deliberately made by the teaching staff).

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

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

We will then run your unit tests in both classes (BulkCarrierTest.java, BulkQuayTest.java) against an incorrect implementation of the respective class (e.g. BulkCarrier.java). For example, the canLoad() method in the BulkCarrier.java file is incorrect.

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

BulkQuayTest.java should still pass 4 unit tests. However, we would expect that BulkCarri-erTest.java would pass fewer than 7 unit tests.

If this is the case, we know that your unit tests can identify that there is a problem with this specific implementation of BulkCarrier.java.

This would get you one identified faulty implementation towards your JUnit mark.

The total marks you receive for JUnit are the correct number of identified faulty implementations, out of the total number of faulty implementations which the teaching staff create.

For example, if your unit tests identified 60% of the faulty implementations, you would receive a mark of: 60% of 15 → 9/15.