Peer Review Form for Robust IntRelation
=======================================

Reviewer information
--------------------

Name:
Id.number:
Date:

Criteria
--------

Rate each of the following five items on a scale from 0 through 2,
and motivate the score.  Enter these results in the template below
the cut line.

When filled out, submit this entire file as review report and submit
the total score as Grade for the peer review.


1. Robust Contracts in IntRelation.java

Precise contracts are an important part of the documentation,
both to develop client code (including test cases) and implementation code.
This, in turn, is improves the maintainability of software.

Indicate to what extent the submitted source code for
IntRelation.java contains contracts that are robust.

A contract is robust when either the precondition is true, or the
contract has one or more @throws clauses that cover all conditions
outside the precondition.  In case of multiple @throws clauses,
their conditions are disjoint.

  2. All constructors and methods have a robust contract.

  1. All except one constructors/methods have robust contracts.

  0. Multiple contructors or methods do not have robust contracts.

Briefly point out enough violations to explain a score < 2.


2. Test Cases for Robust Implementation in IntRelationTestCases.java

Indicate to what extent the test cases in IntRelationTestCases.java
test for robustness.

  2. Each constructor and method that does not have precondition true
     is called under at least one BOUNDARY circumstance to trigger each
     of the exceptions that it can throw, and all these tests check
     that the expected exception is thrown. 

  1. As 2, but one contructor or method is either (i) not fully covered
     (circumstance/exception not missed), or (ii) not tested with a
     boundary case (i.e., "minimal" violation of precondition), or
     (iii) the check is insufficient.

  0. As 2 and 1, but two or more items failed on one contructor/method,
     or two or more constructors/methods are not sufficiently tested
     for robustness.

Briefly point out enough violations to explain a score < 2.


3. Robust Implementation in IntRelationArrays.java

Indicate to what extent the implementation in IntRelationArrrays.java
is robust.

  2. All constructors and methods have robust implementations
     that throw exceptions according to the contract, and each
     thrown exception has a message explaining where it occurred
     and why.

  1. As 2, but one constructor or method misses a precondition check,
     or does not include an appropriate message in the thrown exception.

  0. Two or more methods lack a complete contract.

Briefly point out enough violations to explain a score < 2.


4. Robust Implementation in IntRelationListOfSets.java

Indicate to what extent the implementation in IntRelationListOfSets.java
is robust.

  2. All constructors and methods have robust implementations
     that throw exceptions according to the contract, and each
     thrown exception has a message explaining where it occurred
     and why.

  1. As 2, but one constructor or method misses a precondition check,
     or does not include an appropriate message in the thrown exception.

  0. Two or more methods lack a complete contract.

Briefly point out enough violations to explain a score < 2.


5. No Code Duplication in IntRelationArrays.java and IntRelationListOfSets.java

Indicate to what extent there is code duplication in IntRelationArrays.java
and IntRelationListOfSets.java, in particular, concerning robustness.
That is, code that checks for the same conditions, or code that throws
the same exceptions.

  2. No code duplication for robustness checking.

  1. No code duplication inside the ADT constructors and operations
     (the checking code was refactored into one or more methods inside
     the implementation), but some duplication between the implementations
     (both implementations have similar code for checking).

  0. Code duplication inside ADT constructors and/or operations.

Briefly point out enough violations to explain a score < 2.


-----8<----- cut line -----8<-----

1. Robust Contracts in IntRelation.java

Score: 

Motivation: 

2. Test Cases for Robust Implementation in IntRelationTestCases.java

Score: 

Motivation: 

3. Robust Implementation in IntRelationArrays.java

Score: 

Motivation: 

4. Robust Implementation in IntRelationListOfSets.java

Score: 

Motivation: 

5. No Code Duplication in IntRelationArrays.java and IntRelationListOfSets.java

Score:

Motivation: 

----- -----  --
Total score: 
----- -----  --

(End of Peer Review Form)