180 lines
7.5 KiB
Java
180 lines
7.5 KiB
Java
import java.util.Deque;
|
|
import java.util.ArrayDeque;
|
|
|
|
import static org.junit.Assert.assertTrue; // import static : une facilité offerte depuis java5 (pas besoin de mettre le préfixe)
|
|
import static org.junit.Assert.assertFalse; //
|
|
import static org.junit.Assert.assertSame; //
|
|
import static org.junit.Assert.assertNotSame; //
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.assertArrayEquals;
|
|
import org.junit.Test;
|
|
|
|
|
|
/**
|
|
* Une classe pour faire des tests sur la classe ShuntingYard avec JUnit
|
|
*/
|
|
public class TestShuntingYard1 {
|
|
|
|
|
|
/**
|
|
* ShuntInput déplace un token depuis input vers output
|
|
*
|
|
*/
|
|
@Test
|
|
public void shuntInput(){
|
|
Deque<AbstractToken> expression = new ArrayDeque<AbstractToken>();
|
|
expression.addLast(new TokenConstant(3));
|
|
ShuntingYard se = new ShuntingYard(expression);
|
|
AbstractToken t1 = se.getInput().getFirst();
|
|
se.shuntFromInput();
|
|
AbstractToken t2 = se.getOutput().getLast();
|
|
assertSame(t1,t2);
|
|
}
|
|
|
|
/**
|
|
* PushStack déplace un token depuis input vers stack
|
|
*
|
|
*/
|
|
@Test
|
|
public void pushStack(){
|
|
Deque<AbstractToken> expression = new ArrayDeque<AbstractToken>();
|
|
expression.addLast(new TokenConstant(3));
|
|
expression.addLast(new TokenOperator(Operator.ADD));
|
|
expression.addLast(new TokenConstant(4));
|
|
ShuntingYard se = new ShuntingYard(expression);
|
|
se.shuntFromInput();
|
|
AbstractToken t1 = se.getInput().getFirst();
|
|
se.pushToStack();
|
|
AbstractToken t2 = se.getStack().getFirst();
|
|
assertSame(t1,t2);
|
|
}
|
|
|
|
/**
|
|
* ShuntFromStack déplace un token depuis stack vers output
|
|
*
|
|
*/
|
|
@Test
|
|
public void shuntStack(){
|
|
Deque<AbstractToken> expression = new ArrayDeque<AbstractToken>();
|
|
expression.addLast(new TokenConstant(3));
|
|
expression.addLast(new TokenOperator(Operator.ADD));
|
|
expression.addLast(new TokenConstant(4));
|
|
ShuntingYard se = new ShuntingYard(expression);
|
|
se.shuntFromInput();
|
|
se.pushToStack();
|
|
se.shuntFromInput();
|
|
AbstractToken t1 = se.getStack().getFirst();
|
|
se.shuntFromStack();
|
|
AbstractToken t2 = se.getOutput().getLast();
|
|
assertSame(t1,t2);
|
|
}
|
|
|
|
/**
|
|
* crushParenthesis écrase les parenthèses quand stack est une LB
|
|
* et input est un RB
|
|
*/
|
|
@Test
|
|
public void CandyCrush(){
|
|
Deque<AbstractToken> expression = new ArrayDeque<AbstractToken>();
|
|
expression.addLast(new TokenSeparator(Separator.LB));
|
|
expression.addLast(new TokenConstant(2));
|
|
expression.addLast(new TokenOperator(Operator.SUB2));
|
|
expression.addLast(new TokenConstant(1));
|
|
expression.addLast(new TokenSeparator(Separator.RB));
|
|
ShuntingYard se = new ShuntingYard(expression);
|
|
se.pushToStack();
|
|
se.shuntFromInput();
|
|
se.pushToStack();
|
|
se.shuntFromInput();
|
|
se.shuntFromStack();
|
|
//prêt pour enlever les parenthèses.
|
|
AbstractToken t1 = se.getStack().getFirst();
|
|
TokenSeparator s1 = (TokenSeparator) t1;
|
|
int sizeStackbefore = se.getStack().size();
|
|
AbstractToken t2 = se.getInput().getFirst();
|
|
TokenSeparator s2 = (TokenSeparator) t2;
|
|
int sizeInputbefore = se.getInput().size();
|
|
assertEquals(Separator.LB,s1.getSeparator());
|
|
assertEquals(Separator.RB,s2.getSeparator());
|
|
se.crushParenthesis();
|
|
int sizeStackafter = se.getStack().size();
|
|
int sizeInputafter = se.getInput().size();
|
|
assertEquals(sizeStackbefore-1,sizeStackafter);
|
|
assertEquals(sizeInputbefore-1,sizeInputafter);
|
|
}
|
|
|
|
/**
|
|
* shunbtingTest1 vérifie que tout se passe bien pour l'exemple de ExempleSY1
|
|
*/
|
|
@Test
|
|
public void shuntingTest1(){
|
|
ArrayDeque<AbstractToken> expression = new ArrayDeque<AbstractToken>();
|
|
expression.addLast(new TokenConstant(3));
|
|
expression.addLast(new TokenOperator(Operator.ADD));
|
|
expression.addLast(new TokenConstant(4));
|
|
expression.addLast(new TokenOperator(Operator.MUL));
|
|
expression.addLast(new TokenConstant(2));
|
|
|
|
// moralement on veut tester que les trois structures de données sont les mêmes de manière synchrone entre ceci
|
|
// ShuntingYard se1 = new ShuntingYard(expression);
|
|
// se1.shuntFromInput(); //step1
|
|
// se1.pushToStack(); //step2
|
|
// se1.shuntFromInput(); //step3
|
|
// se1.pushToStack(); //step4
|
|
// se1.shuntFromInput(); //step5
|
|
// se1.shuntFromStack(); //step6
|
|
// se1.shuntFromStack(); //step7
|
|
// et cela
|
|
// ShuntingYard se2 = new ShuntingYard(expression);
|
|
// se2.shunting(); //step1
|
|
// Pour tester on utilise la facilité permettant de comparer élément pas élément deux tableaux.
|
|
// assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
|
|
// assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
|
|
// assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
|
|
ShuntingYard se1 = new ShuntingYard(expression);
|
|
ShuntingYard se2 = new ShuntingYard(expression.clone());// on clone l'expression, car sinon l'input est le même pour les deux exemples
|
|
assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
|
|
assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
|
|
assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
|
|
se1.shuntFromInput(); //step1
|
|
se2.shunting(); //step1
|
|
assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
|
|
assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
|
|
assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
|
|
se1.pushToStack(); //step2
|
|
se2.shunting(); //step2
|
|
assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
|
|
assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
|
|
assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
|
|
se1.shuntFromInput(); //step3
|
|
se2.shunting(); //step3
|
|
assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
|
|
assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
|
|
assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
|
|
se1.pushToStack(); //step4
|
|
se2.shunting(); //step4
|
|
assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
|
|
assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
|
|
assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
|
|
se1.shuntFromInput(); //step5
|
|
se2.shunting(); //step5
|
|
assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
|
|
assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
|
|
assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
|
|
se1.shuntFromStack(); //step6
|
|
se2.shunting(); //step6
|
|
assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
|
|
assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
|
|
assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
|
|
se1.shuntFromStack(); //step7
|
|
se2.shunting(); //step7
|
|
assertArrayEquals("Inputs are not the same",se1.getInput().toArray(),se2.getInput().toArray());
|
|
assertArrayEquals("stacks are not the same",se1.getStack().toArray(),se2.getStack().toArray());
|
|
assertArrayEquals("Output are not the same",se1.getOutput().toArray(),se2.getOutput().toArray());
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|