In: Computer Science
I'm pretty new to JUnit testing. Can someone demonstrate how to
test one of the tree traversals and the add() and addrecursive()
methods?
public class BinaryTree {
private MorseNode<Character> root = new
MorseNode<Character>();
private MorseNode<Character> left = null;
private MorseNode<Character> right =
null;
public MorseNode<Character> getRoot() {
return root;
}
public void printPostorder(MorseNode<Character>
node) {
if(node == null) {return;}
//System.out.print(node.getLetter());
//traverse left subtree
printPostorder(node.getLeft());
//traverse right subtree
printPostorder(node.getRight());
//node
if(node.getLetter() != null) {
System.out.print(node.getLetter()
+ " ");}
}
public void printPreorder(MorseNode<Character>
node) {
if(node == null) {return;}
//System.out.print(node.getLetter());
//node
if(node.getLetter() != null) {
System.out.print(node.getLetter()
+ " ");}
//traverse left
printPreorder(node.getLeft());
//traverse right
printPreorder(node.getRight());
}
public void printInorder(MorseNode<Character>
node) {
if(node == null) {return;}
//System.out.print(node.getLetter());
//traverse left subtree
printInorder(node.getLeft());
//node
if(node.getLetter() != null) {
System.out.print(node.getLetter()
+ " ");}
//traverse right subtree
printInorder(node.getRight());
}
void printInorder() {
System.out.println("Inorder
Traversal: ");
printInorder(root);
System.out.println();
}
void printPreorder() {
System.out.println("PreOrder
Traversal: ");
printPreorder(root);
System.out.println();
}
void printPostorder() {
System.out.println("PostOrder
Traversal: ");
printPostorder(root);
System.out.println();
}
public void add(String str, char letter)
{
//System.out.println(str + "sssssss " + letter );
if (str.charAt(0) == ".".charAt(0)) {
//`System.out.println(str + letter );
root.setLeft(addRecursive(root.getLeft(),
str.substring(1), letter));
}
else if (str.charAt(0) == "-".charAt(0))
root.setRight(addRecursive(root.getRight(), str.substring(1),
letter));
}
public MorseNode<Character>
addRecursive(MorseNode<Character> current, String str,
char letter) {
if (str.length() == 0) {
return new
MorseNode<Character>(letter);
}
if ( Character.compare(str.charAt(0),
".".charAt(0)) == 0) {
current.setLeft(addRecursive(current.getLeft(),
str.substring(1), letter));
} else if
(Character.compare(str.charAt(0), "-".charAt(0)) == 0)
{
current.setRight(addRecursive(current.getRight(),
str.substring(1), letter));
}
return current;
}
}
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
class BinaryTreeTest {
@Test
void testInorder() {
BinaryTree object = new BinaryTree();
char a = 'a',b='c',c='c';
String as = ".",bs = ".-",cs="..";
object.add(as, a);
object.add(bs, b);
object.add(cs, c);
String inorder = "c a b";
}
@Test
void testPostorder() {
}
@Test
void testPreorder() {
}
@Test
void testadd() {
}
}
public class MorseNode<T> {
private T letter; //letter of node
private MorseNode<T> left; //left child
private MorseNode<T> right; //right child
public MorseNode() {
}
public MorseNode(T letter) {
this.letter=letter;
}
//GETS letter in node
public T getLetter() {
return letter;
}
//SETS letter in node
public void setLetter(T letter) {
this.letter = letter;
}
//GETS left child node
public MorseNode<T> getLeft() {
return left;
}
//GETS right child node
public MorseNode<T> getRight() {
return right;
}
//SETS left child node
public void setLeft(MorseNode<T> left) {
this.left = left;
}
//SETS right child node
public void setRight(MorseNode<T> right)
{
this.right = right;
}
//print node
public String toString() {
String str = letter.toString();
return str;
}
}
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.StringTokenizer;
public class MorseNodeDriver {
public static void main(String[] args) throws FileNotFoundException {
BinaryTree theTree = new BinaryTree();
File codeFile = new File("morse.txt");
Scanner myReader = new Scanner(codeFile);
while (myReader.hasNextLine() ) {
String data = myReader.nextLine();
// System.out.println(data);
int len = data.length();
//if (len==2)
theTree.add(data.substring(1), data.charAt(0));
}
theTree.printInorder();
theTree.printPostorder();
theTree.printPreorder();
//System.out.println(theTree.toString());
File translateFile = new File("translate.txt");
Scanner read = new Scanner(translateFile);
System.out.println("\n\n____________Translations__________\n");
while(read.hasNextLine()) {
String morsecode = read.nextLine();
//System.out.println(morsecode);
String[] array = morsecode.split(" ");
for(int x = 0; x< array.length; x++) {
//System.out.println(array[x]);
if(array[x].contentEquals("")) {
System.out.print(" ");
}
else if(array[x].contentEquals(".")) { //e
System.out.print(theTree.getRoot().getLeft());
}
else if(array[x].contentEquals("..")) { //i
System.out.print(theTree.getRoot().getLeft().getLeft());
}
else if(array[x].contentEquals("...")) { //s
System.out.print(theTree.getRoot().getLeft().getLeft().getLeft());
}
else if(array[x].contentEquals("....")) { //h
System.out.print(theTree.getRoot().getLeft().getLeft().getLeft().getLeft());
}
else if(array[x].contentEquals("-")) { //t
System.out.print(theTree.getRoot().getRight());
}
else if(array[x].contentEquals("--")) { //m
System.out.print(theTree.getRoot().getRight().getRight());
}
else if(array[x].contentEquals("---")) { //o
System.out.print(theTree.getRoot().getRight().getRight().getRight());
}
else if(array[x].contentEquals(".-")) { //a
System.out.print(theTree.getRoot().getLeft().getRight());
}
else if(array[x].contentEquals("..-")) { //u
System.out.print(theTree.getRoot().getLeft().getLeft().getRight());
}
else if(array[x].contentEquals("...-")) { //v
System.out.print(theTree.getRoot().getLeft().getLeft().getLeft().getRight());
}
else if(array[x].contentEquals("-.")) { //n
System.out.print(theTree.getRoot().getRight().getLeft());
}
else if(array[x].contentEquals("--.")) { //g
System.out.print(theTree.getRoot().getRight().getRight().getLeft());
}
else if(array[x].contentEquals("-.-")) { //k
System.out.print(theTree.getRoot().getRight().getLeft().getRight());
}
else if(array[x].contentEquals("-..-")) { //x
System.out.print(theTree.getRoot().getRight().getLeft().getLeft().getRight());
}
else if(array[x].contentEquals(".-.")) { //r
System.out.print(theTree.getRoot().getLeft().getRight().getLeft());
}
else if(array[x].contentEquals("-..")) { //d
System.out.print(theTree.getRoot().getRight().getLeft().getLeft());
}
else if(array[x].contentEquals("-.--")) { //y
System.out.print(theTree.getRoot().getRight().getLeft().getRight().getRight());
}
//
else if(array[x].contentEquals(".-..")) { //l
System.out.print(theTree.getRoot().getLeft().getRight().getLeft().getLeft());
}
else if(array[x].contentEquals("..-.")) { //f
System.out.print(theTree.getRoot().getLeft().getLeft().getRight().getLeft());
}
else if(array[x].contentEquals("-...")) { //b
System.out.print(theTree.getRoot().getRight().getLeft().getLeft().getLeft());
}
else if(array[x].contentEquals("-.-.")) { //c
System.out.print(theTree.getRoot().getRight().getLeft().getRight().getLeft());
}
else if(array[x].contentEquals(".---")) { //j
System.out.print(theTree.getRoot().getLeft().getRight().getRight().getRight());
}
else if(array[x].contentEquals(".--.")) { //p
System.out.print(theTree.getRoot().getLeft().getRight().getRight().getLeft());
}
else if(array[x].contentEquals("--.-")) { //q
System.out.print(theTree.getRoot().getRight().getRight().getLeft().getRight());
}
else if(array[x].contentEquals(".--")) { //w
System.out.print(theTree.getRoot().getLeft().getRight().getRight());
}
else if(array[x].contentEquals("--..")) { //z
System.out.print(theTree.getRoot().getRight().getRight().getLeft().getLeft());
}
}
System.out.println();
}
//System.out.println(theTree.getRoot().getLeft().getLeft().getLeft().getLeft());
}
}
////////////////////////////////// Any problem , add in comment ////////////////////////////////////////
///////////////////////// System.out.println chnage to System.out.print("\n"); /////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
public class MorseNode<T> {
private T letter; //letter of node
private MorseNode<T> left; //left child
private MorseNode<T> right; //right child
public MorseNode() {
}
public MorseNode(T letter) {
this.letter=letter;
}
//GETS letter in node
public T getLetter() {
return letter;
}
//SETS letter in node
public void setLetter(T letter) {
this.letter = letter;
}
//GETS left child node
public MorseNode<T> getLeft() {
return left;
}
//GETS right child node
public MorseNode<T> getRight() {
return right;
}
//SETS left child node
public void setLeft(MorseNode<T> left) {
this.left = left;
}
//SETS right child node
public void setRight(MorseNode<T> right) {
this.right = right;
}
//print node
public String toString() {
String str = letter.toString();
return str;
}
}
//////////////////////////////////////////////////////////////////////
public class BinaryTree {
private MorseNode<Character> root = new
MorseNode<Character>();
private MorseNode<Character> left = null;
private MorseNode<Character> right = null;
public MorseNode<Character> getRoot() {
return root;
}
public void printPostorder(MorseNode<Character> node) {
if(node == null) {return;}
//System.out.print(node.getLetter());
//traverse left subtree
printPostorder(node.getLeft());
//traverse right subtree
printPostorder(node.getRight());
//node
if(node.getLetter() != null) {
System.out.print(node.getLetter() + " ");}
}
public void printPreorder(MorseNode<Character> node)
{
if(node == null) {return;}
//System.out.print(node.getLetter());
//node
if(node.getLetter() != null) {
System.out.print(node.getLetter() + " ");}
//traverse left
printPreorder(node.getLeft());
//traverse right
printPreorder(node.getRight());
}
public void printInorder(MorseNode<Character> node) {
if(node == null) {return;}
//System.out.print(node.getLetter());
//traverse left subtree
printInorder(node.getLeft());
//node
if(node.getLetter() != null) {
System.out.print(node.getLetter() + " ");}
//traverse right subtree
printInorder(node.getRight());
}
void printInorder() {
System.out.print("InOrder Traversal: \n");
printInorder(root);
System.out.print("\n");
}
void printPreorder() {
System.out.print("PreOrder Traversal: \n");
printPreorder(root);
System.out.print("\n");
}
void printPostorder() {
System.out.print("PostOrder Traversal: \n");
printPostorder(root);
System.out.print("\n");
}
public void add(String str, char letter) {
//System.out.println(str + "sssssss " + letter );
if (str.charAt(0) == ".".charAt(0)) {
//`System.out.println(str + letter );
root.setLeft(addRecursive(root.getLeft(), str.substring(1),
letter));
}
else if (str.charAt(0) == "-".charAt(0))
root.setRight(addRecursive(root.getRight(), str.substring(1),
letter));
}
public MorseNode<Character>
addRecursive(MorseNode<Character> current, String str, char
letter) {
if (str.length() == 0) {
return new MorseNode<Character>(letter);
}
if ( Character.compare(str.charAt(0), ".".charAt(0)) == 0)
{
current.setLeft(addRecursive(current.getLeft(), str.substring(1),
letter));
} else if (Character.compare(str.charAt(0), "-".charAt(0)) == 0)
{
current.setRight(addRecursive(current.getRight(), str.substring(1),
letter));
}
return current;
}
}
/////////////////////////////////////////////////////////////////////////// junit testing
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.*;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class BinaryTreeTest {
private final PrintStream standardOut =
System.out;
private final ByteArrayOutputStream outputStreamCaptor
= new ByteArrayOutputStream();
@BeforeEach
public void setUp() {
System.setOut(new
PrintStream(outputStreamCaptor));
}
@Test
void testInorder() {
BinaryTree object = new BinaryTree();
char a = 'a',b='b',c='c';
String as = ".",bs = ".-",cs="..";
object.add(as, a);
object.add(bs, b);
object.add(cs, c);
String inorder = "InOrder Traversal: \nc a b \n";
object.printInorder();
assertEquals(inorder, outputStreamCaptor.toString());
}
@Test
void testPostorder() {
BinaryTree object = new BinaryTree();
char a = 'a',b='b',c='c';
String as = ".",bs = ".-",cs="..";
object.add(as, a);
object.add(bs, b);
object.add(cs, c);
String postorder = "PostOrder Traversal: \nc b a
\n";
object.printPostorder();
assertEquals(postorder,
outputStreamCaptor.toString());
}
@Test
void testPreorder() {
BinaryTree object = new BinaryTree();
char a = 'a',b='b',c='c';
String as = ".",bs = ".-",cs="..";
object.add(as, a);
object.add(bs, b);
object.add(cs, c);
String preorder = "PreOrder Traversal: \na c b \n";
object.printPreorder();
assertEquals(preorder,
outputStreamCaptor.toString());
}
@Test
void testadd() {
BinaryTree object = new BinaryTree();
char a = 'p',b='q',c='r';
String as = ".",bs = ".-",cs="..";
object.add(as, a);
object.add(bs, b);
object.add(cs, c);
String inorder = "InOrder Traversal: \nr p q
\n";
object.printInorder();
String preorder = "PreOrder Traversal: \np r q
\n";
object.printPreorder();
String postorder = "PostOrder Traversal: \nr q p
\n";
object.printPostorder();
assertEquals(inorder+preorder+postorder,
outputStreamCaptor.toString());
}
}
////////////////////////////////////////////////////