Okay so I have read the guidelines and don't believe this post is against the rules or against the rules for asking for help because I have put in an effort and I'm around 70 percent in testing the files. I just need help with this basic Java code to see what I'm doing wrong.
We just have to make the three classes test at 100 percent and correspond to the test packages.
Here is my code:
package model;
public class Player {
private String name;
private int cash;
private int Holding1;
private int Holding2;
private int Holding3;
/**
* @return the name
*/
public Player() {
name="?";
cash=5000;
Holding1=0;
Holding2=0;
Holding3=0;
}
public Player(String MyName, int MyCash, int MyHolding1, int MyHolding2, int MyHolding3){
name = MyName;
cash = MyCash;
Holding1=MyHolding1;
Holding2=MyHolding2;
Holding3=MyHolding3;
}
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the cash
*/
public int getCash() {
return cash;
}
/**
* @param cash the cash to set
*/
public void setCash(int cash) {
this.cash = cash;
}
/**
* @return the Holding1
*/
public int getHolding1() {
return Holding1;
}
/**
* @param Holding1 the Holding1 to set
*/
public void setHolding1(int Holding1) {
this.Holding1 = Holding1;
}
/**
* @return the Holding2
*/
public int getHolding2() {
return Holding2;
}
/**
* @param Holding2 the Holding2 to set
*/
public void setHolding2(int Holding2) {
this.Holding2 = Holding2;
}
/**
* @return the Holding3
*/
public int getHolding3() {
return Holding3;
}
/**
* @param Holding3 the Holding3 to set
*/
public void setHolding3(int Holding3) {
this.Holding3 = Holding3;
}
}package model;
public class Game {
private boolean Started;
private boolean Over;
private Player player;
private Stock stock1;
private Stock stock2;
private Stock stock3;
/**
* @return the Started
*/
public Game(){
Started = false;
Over = false;
player=null;
stock1=null;
stock2=null;
stock3=null;
}
public Game(Stock gold, Stock oil, Stock grain, Player george){
setStock1(gold);
setStock2(oil);
setStock3(grain);
setPlayer(george);}
/**
* @return the Started
*/
public boolean isStarted() {
return Started;
}
/**
* @param Started the Started to set
*/
public void setStarted(boolean Started) {
this.Started = Started;
}
/**
* @return the Over
*/
public boolean isOver() {
return Over;
}
/**
* @param Over the Over to set
*/
public void setOver(boolean Over) {
this.Over = Over;
}
/**
* @return the player
*/
public Player getPlayer() {
return player;
}
/**
* @param player the player to set
*/
public void setPlayer(Player player) {
this.player = player;
}
/**
* @return the stock1
*/
public Stock getStock1() {
return stock1;
}
/**
* @param stock1 the stock1 to set
*/
public void setStock1(Stock stock1) {
this.stock1 = stock1;
}
/**
* @return the stock2
*/
public Stock getStock2() {
return stock2;
}
/**
* @param stock2 the stock2 to set
*/
public void setStock2(Stock stock2) {
this.stock2 = stock2;
}
/**
* @return the stock3
*/
public Stock getStock3() {
return stock3;
}
/**
* @param stock3 the stock3 to set
*/
public void setStock3(Stock stock3) {
this.stock3 = stock3;
}
}and the test packages they need to correspond to
package model;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
public class GameTest {
public GameTest() {
}
public void testDefaultConstructor() {
System.out.println("Constructor");
Game instance = new Game();
// everything has better be false or null!
assertEquals("Default setting - started", false, instance.isStarted());
assertEquals("Default setting - over", false, instance.isOver());
assertNull("Default setting - player", instance.getPlayer());
assertNull("Default setting - stock1", instance.getStock1());
assertNull("Default setting - stock2", instance.getStock2());
assertNull("Default setting - stock3", instance.getStock3());
}
/**
* Test the convenience Stock constructor
*/
@Test
public void testConvenienceConstructor() {
System.out.println("Constructor (convenience)");
// Setup some dummy data
Stock gold = new Stock("GOLD", "Mining", 100);
Stock oil = new Stock("OIL", "Resources", 100);
Stock grain = new Stock("GRAN", "Farming", 100);
Player george = new Player("George", 5000);
// And make a game out of these
Game game = new Game(gold, oil, grain, george);
assertEquals("Default setting - started", false, game.isStarted());
assertEquals("Default setting - over", false, game.isOver());
assertEquals("Specified setting - player", george, game.getPlayer());
assertEquals("Specified setting - stock1", gold, game.getStock1());
assertEquals("Specified setting - stock2", oil, game.getStock2());
assertEquals("Specified setting - stock3", grain, game.getStock3());
}
/**
* Test of isStarted method, of class Game.
*/
@Test
public void testStarted() {
System.out.println("setStarted");
Game instance = new Game();
boolean expResult = false;
instance.setStarted(expResult);
assertEquals("Setting started flag off", expResult, instance.isStarted());
expResult = true;
instance.setStarted(expResult);
assertEquals("Setting started flag on", expResult, instance.isStarted());
}
/**
* Test of isOver method, of class Game.
*/
@Test
public void testOver() {
System.out.println("setOver");
Game instance = new Game();
boolean expResult = false;
instance.setOver(expResult);
assertEquals("Setting Over flag off", expResult, instance.isOver());
expResult = true;
instance.setOver(expResult);
assertEquals("Setting Over flag on", expResult, instance.isOver());
}
/**
* Test of setStock1 method, of class Game.
*/
@Test
public void testSetStock1() {
System.out.println("setStock1");
Stock gold = new Stock("GOLD", "Mining", 100);
Stock oil = new Stock("OIL", "Resources", 100);
Stock grain = new Stock("GRAN", "Farming", 100);
// test what should be good values
Stock[] good = {gold, oil, grain};
for (Stock expResult : good) {
Game instance = new Game();
instance.setStock1(expResult);
assertEquals("Good stock1 rejected", expResult, instance.getStock1());
}
// test what will be bad values, but they're ok at this point
Stock[] bad = {null};
for (Stock expResult : bad) {
Game instance = new Game();
instance.setStock1(expResult);
assertEquals("Bad stock1 prematurely rejected", expResult, instance.getStock1());
}
}
/**
* Test of setStock2 method, of class Game.
*/
@Test
public void testSetStock2() {
System.out.println("setStock2");
Stock gold = new Stock("GOLD", "Mining", 100);
Stock oil = new Stock("OIL", "Resources", 100);
Stock grain = new Stock("GRAN", "Farming", 100);
// test what should be good values
Stock[] good = {gold, oil, grain};
for (Stock expResult : good) {
Game instance = new Game();
instance.setStock2(expResult);
assertEquals("Good stock2 rejected", expResult, instance.getStock2());
}
// test what will be bad values, but they're ok at this point
Stock[] bad = {null};
for (Stock expResult : bad) {
Game instance = new Game();
instance.setStock2(expResult);
assertEquals("Bad stock1 prematurely rejected", expResult, instance.getStock2());
}
}
/**
* Test of setStock3 method, of class Game.
*/
@Test
public void testSetStock3() {
System.out.println("setStock3");
Stock gold = new Stock("GOLD", "Mining", 100);
Stock oil = new Stock("OIL", "Resources", 100);
Stock grain = new Stock("GRAN", "Farming", 100);
// test what should be good values
Stock[] good = {gold, oil, grain};
for (Stock expResult : good) {
Game instance = new Game();
instance.setStock3(expResult);
assertEquals("Good stock3 rejected", expResult, instance.getStock3());
}
// test what will be bad values, but they're ok at this point
Stock[] bad = {null};
for (Stock expResult : bad) {
Game instance = new Game();
instance.setStock3(expResult);
assertEquals("Bad stock3 prematurely rejected", expResult, instance.getStock3());
}
}
/**
* Test of setPlayer method, of class Game.
*/
@Test
public void testSetPlayer() {
System.out.println("setPlayer");
Player tom = new Player("Tom", 1000);
Player dick = new Player("Dick", 50000);
Player harry = new Player("Harry", 5000);
Player joe = new Player();
// test what should be good values
Player[] good = {tom, dick, harry};
for (Player expResult : good) {
Game instance = new Game();
instance.setPlayer(expResult);
assertEquals("Good player rejected", expResult, instance.getPlayer());
}
// test what will be bad values, but they're ok at this point
Player[] bad = {null, joe};
for (Player expResult : bad) {
Game instance = new Game();
instance.setPlayer(expResult);
assertEquals("Bad player prematurely rejected", expResult, instance.getPlayer());
}
}package model;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
public class PlayerTest {
public PlayerTest() {
}
/**
* Test the default Player constructor
*/
@Test
public void testDefaultConstructor() {
System.out.println("Constructor");
Player instance = new Player();
assertEquals("Default setting - name", "?", instance.getName());
assertEquals("Default setting - cash", 5000, instance.getCash());
assertEquals("Default setting - holding1", 0, instance.getHolding1());
assertEquals("Default setting - holding2", 0, instance.getHolding2());
assertEquals("Default setting - holding3", 0, instance.getHolding3());
}
/**
* Test the convenience Player constructor
*/
@Test
public void testConvenienceConstructor() {
System.out.println("Constructor (convenience)");
Player instance = new Player("Henri", 2000);
assertEquals("Default setting - name", "Henri", instance.getName());
assertEquals("Default setting - cash", 2000, instance.getCash());
assertEquals("Default setting - holding1", 0, instance.getHolding1());
assertEquals("Default setting - holding2", 0, instance.getHolding2());
assertEquals("Default setting - holding3", 0, instance.getHolding3());
}
/**
* Test of setName method, of class Player.
*/
@Test
public void testSetName() {
System.out.println("setName");
// test what should be good values
String[] good = {"George", "Henri", "StRaNgE_bUt_lEgAl"};
for (String expResult : good) {
Player instance = new Player();
instance.setName(expResult);
assertEquals("Good name rejected", expResult, instance.getName());
}
// test what will be bad values, but they're ok at this point
String[] bad = {"", null, "James L", "Hmm - I wonder if we should have a restriction on the length of a name, or should we allow ridiculously long stock names?"};
for (String expResult : bad) {
Player instance = new Player();
instance.setName(expResult);
assertEquals("Bad name prematurely rejected", expResult, instance.getName());
}
}
/**
* Test of setCash method, of class Player.
*/
@Test
public void testSetCash() {
System.out.println("setCash");
// test what should be good values
int[] good = {50, 500, 1000, 5000, 100000};
for (int expResult : good) {
Player instance = new Player();
instance.setCash(expResult);
assertEquals("Good value rejected", expResult, instance.getCash());
}
// test what will be bad values, but they're ok at this point
int[] bad = {-5, 0, 201, 1, 2, 77};
for (int expResult : bad) {
Player instance = new Player();
instance.setCash(expResult);
assertEquals("Bad value prematurely rejected", expResult, instance.getCash());
}
}
/**
* Test of setHolding1 method, of class Player.
*/
@Test
public void testSetHolding1() {
System.out.println("setHolding1");
// test what should be good values
int[] good = {0, 50, 500, 1000, 5000, 100000};
for (int expResult : good) {
Player instance = new Player();
instance.setHolding1(expResult);
assertEquals("Good value rejected", expResult, instance.getHolding1());
}
// test what will be bad values, but they're ok at this point
int[] bad = {-5, 201, 1, 2, 77};
for (int expResult : bad) {
Player instance = new Player();
instance.setHolding1(expResult);
assertEquals("Bad value prematurely rejected", expResult, instance.getHolding1());
}
}
/**
* Test of setHolding2 method, of class Player.
*/
@Test
public void testSetHolding2() {
System.out.println("setHolding2");
// test what should be good values
int[] good = {0, 50, 500, 1000, 5000, 100000};
for (int expResult : good) {
Player instance = new Player();
instance.setHolding2(expResult);
assertEquals("Good value rejected", expResult, instance.getHolding2());
}
// test what will be bad values, but they're ok at this point
int[] bad = {-5, 201, 1, 2, 77};
for (int expResult : bad) {
Player instance = new Player();
instance.setHolding2(expResult);
assertEquals("Bad value prematurely rejected", expResult, instance.getHolding2());
}
}
/**
* Test of setHolding3 method, of class Player.
*/
@Test
public void testSetHolding3() {
System.out.println("setHolding3");
// test what should be good values
int[] good = {0, 50, 500, 1000, 5000, 100000};
for (int expResult : good) {
Player instance = new Player();
instance.setHolding3(expResult);
assertEquals("Good value rejected", expResult, instance.getHolding3());
}
// test what will be bad values, but they're ok at this point
int[] bad = {-5, 201, 1, 2, 77};
for (int expResult : bad) {
Player instance = new Player();
instance.setHolding3(expResult);
assertEquals("Bad value prematurely rejected", expResult, instance.getHolding3());
}
}
/**
* Test of toString method, of class Player.
*/
@Test
public void testToString() {
System.out.println("toString");
Player instance = new Player();
String expResult = "?... $5000 cash and 0/0/0 holdings";
String result = instance.toString();
assertEquals("Text representation from default constructor", expResult, result);
instance = new Player("John", 111);
expResult = "John... $111 cash and 0/0/0 holdings";
result = instance.toString();
assertEquals("Text representation from convenience constructor", expResult, result);
instance.setHolding1(500);
instance.setHolding2(1000);
instance.setHolding3(500);
expResult = "John... $111 cash and 500/1000/500 holdings";
result = instance.toString();
assertEquals("Text representation from convenience constructor", expResult, result);
}
/**
* Test of equals method, of class Player.
*/
@Test
public void testEquals() {
System.out.println("equals");
Player tom = new Player("Tom", 1000);
Player harry = new Player("Harry", 5000);
Player henri = new Player("Harry", 100);
// identical objects
assertTrue("Tom is Tom", tom.equals(tom));
// same objects
assertTrue("Harry and Henri are the same", harry.equals(henri));
// not same objects
assertFalse("Tom and Harry are different", tom.equals(harry));
}
}The errors I notice in the test packages are:
"Player tom = new Player("Tom", 1000);
Player harry = new Player("Harry", 5000);
Player henri = new Player("Harry", 100);"
"instance = new Player("John", 111);"
"Player george = new Player("George", 5000);"
So it's something to do with that and I'm stuck. There is no advanced code needed, just wonder if it's something to do with the player class or game class and what code is needed to take it out.
