[SOLVED] Comp1210 project: ring torus with junit tests – part 1

Overview: This project consists of two classes: (1) RingTorus is a class representing a RingTorus
object and (2) RingTorusTest is a JUnit test class which contains one or more test methods for each
method in the RingTorus class. Note that there is no requirement for a class with a main method in
this project.
You should create a new folder to hold the files for this project. After you have created your
RingTorus.java file, you should create a jGRASP project and add your RingTorus.java file; you
should see it in the Source Files category of the Project section of the Browse tab. With this project is
open, your test file, RingTorusTest.java, will be automatically added to the project when it is created;
you should see it in the Test Files category. If RingTorusTest.java appears in source File category,
you should right-click on the file and select “Mark As Test” from the right-click menu. You will then
be able to run the test file by clicking the JUnit run button on the Open Projects toolbar.
A ring torus is made by revolving a small circle with radius r along a line made by a larger circle
with radius R as shown below.
Variables in formulas:
�: radius of large circle (or large radius)
�: radius of small circle (or small radius)
A: surface area
V: volume
D: ring diameter
D = 2 (R + r)
� = (2��) (2��)
� = (2��) (��!)
Project: Ring Torus with JUnit Tests – Part 1 Page 2 of 5
Page 2 of 5
• RingTorus.java
Requirements: Create a RingTorus class that stores the label, small radius, and large radius
where the small radius is less than the large radius and both are positive. The RingTorus class
also includes methods to set and get each of these fields, as well as methods to calculate the
outside diameter, surface area, and volume of a RingTorus object, and a method to provide a
String value that describes a RingTorus object. The RingTorus class includes a one static field
(or class variable) to track the number of RingTorus objects that have been created, as well
appropriate static methods to access and reset this field. And finally, this class provides a method
that JUnit will use to test RingTorus objects for equality as well as a method required by
Checkstyle.
Design: The RingTorus class has fields, a constructor, and methods as outlined below.
(1) Fields: Instance Variables – label of type String, large radius of type double, and small
radius of type double. Initialize the String to “” and the double variables to 0 in their
respective declarations. These instance variables should be private so that they are not
directly accessible from outside of the RingTorus class, and these should be the only instance
variables (fields) in the class.
Class Variable – count of type int should be private and static, and it should be initialized to
zero in the declaration.
(2) Constructor: Your RingTorus class must contain a public constructor that accepts three
parameters (see types of above) representing the label, large radius, and small radius. Instead
of assigning the parameters directly to the fields, the respective set method for each field
(described below) should be called since they are checking the validity of the parameter. For
example, instead of using the statement label = labelIn; use the statement
setLabel(labelIn);
After setLabel is called be sure to call setLargeRadius before calling setSmallRadius. The
constructor should increment the class variable count each time a RingTorus is constructed.
Below are examples of how the constructor could be used to create RingTorus objects. Note
that although String and numeric literals are used for the actual parameters (or arguments) in
these examples, variables of the required type could have been used instead of the literals.
RingTorus ex1 = new RingTorus (“Small Example”, 9.5, 1.25);
RingTorus ex2 = new RingTorus (” Medium Example “, 35.1, 10.4);
RingTorus ex3 = new RingTorus (“Large Example”, 134.28, 32.46);
(3) Methods: Usually a class provides methods to access and modify each of its instance
variables (known as get and set methods) along with any other required methods. The
methods for RingTorus, which should each be public, are described below. See the formulas
in the figure above and the Code and Test section below for information on constructing these
methods.
Project: Ring Torus with JUnit Tests – Part 1 Page 3 of 5
Page 3 of 5
o getLabel: Accepts no parameters and returns a String representing the label field.
o setLabel: Takes a String parameter and returns a boolean. If the String
parameter is not null, then the “trimmed” String is set to the label field and the
method returns true. Otherwise, the method returns false and the label is not set.
o getLargeRadius: Accepts no parameters and returns a double representing the
large radius field.
o setLargeRadius: Takes a double parameter and returns a boolean. If the
double parameter is positive and is greater than the current small radius, then the
parameter is assigned to the large radius field and the method returns true. Otherwise,
the method returns false and the large radius field is not set.
o getSmallRadius: Accepts no parameters and returns a double representing the
small radius field.
o setSmallRadius: Takes a double parameter and returns a boolean. If the
double parameter is positive and is less than the current large radius, then the parameter
is assigned to the small radius field and the method returns true. Otherwise, the method
returns false and the small radius field is not set.
o diameter: Accepts no parameters and returns a double representing the diameter of
the RingTorus. See formula in figure on page 1.
o surfaceArea: Accepts no parameters and returns the double value for the surface
area of the RingTorus. See formula in figure on page 1.
o volume: Accepts no parameters and returns the double value for the volume of the
RingTorus. See formula in figure on page 1.
o toString: Returns a String containing the information about the RingTorus object
formatted as shown below, including decimal formatting (“#,##0.0##”) for the double
values. Newline and tab escape sequences should be used to achieve the proper layout
within the String but it should not begin or end with a newline. In addition to the field
values (or corresponding “get” methods), the following methods should be used to
compute appropriate values in the toString method: diameter(),
surfaceArea(), and volume(). Each line should have no trailing spaces (e.g., there
should be no spaces before a newline (
) character). The toString value for ex1,
ex2, and ex3 respectively are shown below (the blank lines are not part of the
toString values).
RingTorus “Small Example”
large radius = 9.5 units
small radius = 1.25 units
diameter = 21.5 units
surface area = 468.806 square units
volume = 293.004 cubic units
RingTorus “Medium Example”
large radius = 35.1 units
small radius = 10.4 units
diameter = 91.0 units
surface area = 14,411.202 square units
volume = 74,938.248 cubic units
Project: Ring Torus with JUnit Tests – Part 1 Page 4 of 5
Page 4 of 5
RingTorus “Large Example”
large radius = 134.28 units
small radius = 32.46 units
diameter = 333.48 units
surface area = 172,075.716 square units
volume = 2,792,788.867 cubic units
o getCount: A static method that accepts no parameters and returns an int representing
the static count field.
o resetCount: A static method that returns nothing, accepts no parameters, and sets the
static count field to zero.
o equals: An instance method that accepts a parameter of type Object and returns false if
the Object is a not a RingTorus; otherwise, when cast to a RingTorus, if it has the same
field values (ignoring case in the label field) as the RingTorus upon which the method
was called, it returns true. Otherwise, it returns false. Note that this equals method with
parameter type Object will be called by the JUnit Assert.assertEquals method when two
RingTorus objects are checked for equality.
Below is a version you are free to use.
public boolean equals(Object obj) {

if (!(obj instanceof RingTorus )) {
return false;
}
else {
RingTorus rt = (RingTorus ) obj;
return (label.equalsIgnoreCase(rt.getLabel())
&& (Math.abs(largeRadius – rt.getLargeRadius()) < .000001)
&& (Math.abs(smallRadius – rt.getSmallRadius()) < .000001));
}
}
o hashCode(): Accepts no parameters and returns zero of type int. This method is
required by Checkstyle if the equals method above is implemented.
Code and Test: As you implement the methods in your RingTorus class, you should compile it
and then create test methods as described below for the RingTorusTest class.
When using the setSmallRadius and setLargeRadius, the values of the current smallRadius and
largeRadius must be considered to decide the order in which you invoke the associated set
methods. For setSmallRadius, the “new” small radius must be positive and smaller the current
large radius, and for setLargeRadius, the “new” large radius must be positive and larger the
current small radius. For example, a new RingTorus object has its smallRadius and largeRadius
fields initialized to zero in the field declaration, which is default initial value for doubles.
However, this means in the constructor, you must invoke the setLargeRadius before the
setSmallRadius. If you wanted a small radius of 2.5 and attempt to set it first, it would not be set
since it will not be less than largeRadius, which is initially zero. Thus, you invoke setLargeRadius
first since any positive value will be greater than the smallRadius which is initially zero.
Project: Ring Torus with JUnit Tests – Part 1 Page 5 of 5
Page 5 of 5
Therefore, in general you need to consider the current value the smallRadius and largeRadius to
decide the order you invoke the associated set methods.
• RingTorusTest.java
Requirements: Create a RingTorusTest class that contains a set of test methods to test each of
the methods in RingTorus.
Design: Typically, in each test method, you will need to create an instance of RingTorus , call the
method you are testing, and then make an assertion about the expected result and the actual result
(note that the actual result is commonly the result of invoking the method unless it has a void
return type). You can think of a test method as simply formalizing or codifying what you could
be doing in jGRASP interactions to make sure a method is working correctly. That is, the
sequence of statements that you would enter in interactions to test a method should be entered
into a single test method. You should have at least one test method for each method in
RingTorus, except for associated getters and setters which can be tested in the same method.
Collectively, these test methods are a set of test cases that can be invoked with a single click to
test all the methods in your RingTorus class.
Code and Test: Since this is the first project requiring you to write JUnit test methods, a good
strategy would be to begin by writing test methods for those methods in RingTorus that you
“know” are correct. By doing this, you will be able to concentrate on the getting the test methods
correct. That is, if the test method fails, it is most likely due to a defect in the test method itself
rather the RingTorus method being testing. As you become more familiar with the process of
writing test methods, you will be better prepared to write the test methods as new methods are
developed. Be sure to call the RingTorus toString method in one of your test methods and
assert something about the return value. If you do not want to use assertEquals, which would
require the return value match the expected value exactly, you could use assertTrue and check
that the return value simply contains the expected value. For example, for RingTorus ex3:
Assert.assertTrue(ex3.toString().contains(“”Large Example””));
Also, remember that you can set a breakpoint in a JUnit test method and run the test file in Debug
mode. Then, when you have an instance in the Debug tab, you can unfold it to see its values or
you can open a canvas window and drag items from the Debug tab onto the canvas.
The Grading System
When you submit RingTorus.java and RingTorusTest.java, the grading system will use the results of your
test methods and their level of coverage of your source files as well as the results of our reference
correctness tests to determine your grade. In this project, your test file should provide at least method
coverage. That is, each method must be called at least once in a test method.