JACK Wiki - Benutzerbeiträge [de]

UnaryMinus

2017-09-19T06:49:04Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktion ''UnaryMinus'' (-) setzt eine positive Zahl ins negative und eine negative Zahl ins positive.

===Syntax===
-a

===Parameter===
* '''a''' - double

===Return Value===
* Gibt die positive oder negative Zahl zurück

===Beispiele===
-8 --> -8
-(-5) --> 5

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
fillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));

exerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));
}

@Test
public void testUnaryMinus1() {
assertEquals(-8, Evaluator.getNumberResult("-8", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testUnaryMinus2() {
assertEquals(-2, Evaluator.getNumberResult("-2", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testUnaryMinus3() {
assertEquals(-2.2, Evaluator.getNumberResult("-2.2", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testUnaryMinusWithInput1() {
assertEquals(-3, Evaluator.getNumberResult("-[pos=1]", exerciseVariableMap, fillInVariableMap), 0.0);

}

@Test
public void testUnaryMinusWithInput2() {
assertEquals(-1, Evaluator.getNumberResult("-[pos=2]", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testUnaryMinusWithVariables1() {
assertEquals(-3, Evaluator.getNumberResult("-[var=a]", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testUnaryMinusWithVariables2() {
assertEquals(-1, Evaluator.getNumberResult("-[var=b]", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testUnaryMinusWithExpressions1() {
assertEquals(5, Evaluator.getNumberResult("-(-5)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testUnaryMinusWithExpressions2() {
assertEquals(-4, Evaluator.getNumberResult("-(-(-4))", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testUnaryMinusWithWrongInputCharacter() {
assertEquals(-5, Evaluator.getNumberResult("-'aabc'", exerciseVariableMap, fillInVariableMap), 0.0);
}
</syntaxhighlight>

===Hinweise===
* erwartet eine Zahl

[[Kategorie:Evaluatorfunktion]]

Trim

2017-09-19T06:48:16Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''trim'' entfernt aus einer Zeichenkette alle am Anfang und am Ende stehende Leerzeichen. Die Funktion erwartet einen String und gibt eine modifizierte Zeichenkette als String zurück.

=== Syntax ===
trim(String zeichenkette)

=== Parameter ===
* '''zeichenkette''' - die Zeichenkette bei der die am Anfang und Ende befindlichen Leerzeichen entfernt werden sollen

=== Return Value ===
* Gibt einen Stringzurück

=== Beispiele ===
====Standardfälle====
trim(' Leerzeichen wurden entfernt ') --> returns 'Leerzeichen wurden entfernt'
trim(' hello') --> returns 'hello'

====Benutzung mit Variablen====
trim('[pos=1]')
trim('[var=a]')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@Before
public void beforeTest() {
fillInVariableMap.put(7, OMConverter.toObject("<OMOBJ><OMSTR>hello</OMSTR></OMOBJ>"));

exerciseVariableMap.put("g", OMConverter.toObject("<OMOBJ><OMSTR>hello</OMSTR></OMOBJ>"));
}

@Test
public void testTrim1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("hello")),
Evaluator.evaluate("trim(' hello')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testTrim2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("hello")),
Evaluator.evaluate("trim('hello ')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testTrim3() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("hello")),
Evaluator.evaluate("trim(' hello ')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testTrim4() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("hel lo")),
Evaluator.evaluate("trim(' hel lo ')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testTrimWithExpression1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("w o r k")),
Evaluator.evaluate("trim(trim(' w o r k '))", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testTrimWithExpression2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("w o r k")),
Evaluator.evaluate("trim(trim(trim(' w o r k ')))", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testTrimWithInput() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("hello")),
Evaluator.evaluate("trim(' [pos=7] ')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testTrimWithVariables() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("hello")),
Evaluator.evaluate("trim(' [var=g] ')", exerciseVariableMap, fillInVariableMap));
}

@Test(expected = ParserException.class)
public void testTrimWithWrongInputCharacter() {
Evaluator.evaluate("trim(ab)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testTrimWithTwoArguments() {
Evaluator.evaluate("trim(' a', 'a ')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testTrimWithThreeArguments() {
Evaluator.evaluate("trim(' a', 'a ', ' a ')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testTrimWithMissingExerciseVariable() {
Evaluator.evaluate("trim('[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testTrimWithMissingInput() {
Evaluator.evaluate("trim('[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===
* Es werden keine Leerzeichen zwischen den Wörtern der Zeichenkette entfernt.
* '''Im Moment werden jedoch alle Leerzeichen entfernt!'''

[[Kategorie:Evaluatorfunktion]]

ToUpperCase

2017-09-19T06:47:43Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''toUpperCase'' wandelt alle Buchstaben einer Zeichenkette in Großbuchstaben um. Die Funktion erwartet einen String und gibt einen String zurück.

=== Syntax ===
toUpperCase(String zeichenkette)

=== Parameter ===
* '''zeichenkette''' - die Zeichenkette, in der alle Buchstaben in Großbuchstaben umgewandelt werden sollen

=== Return Value ===
* Gibt einen String zurück

=== Beispiele ===
====Standardfälle====
toUpperCase('ich bin klein') --> returns 'ICH BIN KLEIN'
toUpperCase('abcdefghijklmnopqrstuvwxyz') --> returns 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
toUpperCase('1234567890.!\"§$%&/()=?') --> returns '1234567890.!\"§$%&/()=?'

====Benutzung mit Variablen====
toUpperCase('[pos=1]')
toUpperCase('[var=a]')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@Before
public void beforeTest() {
fillInVariableMap.put(7, OMConverter.toObject("<OMOBJ><OMSTR>hello</OMSTR></OMOBJ>"));
fillInVariableMap.put(8, OMConverter.toObject("<OMOBJ><OMSTR>hello3</OMSTR></OMOBJ>"));

exerciseVariableMap.put("g", OMConverter.toObject("<OMOBJ><OMSTR>hello</OMSTR></OMOBJ>"));
exerciseVariableMap.put("h", OMConverter.toObject("<OMOBJ><OMSTR>hello3</OMSTR></OMOBJ>"));
}

@Test
public void testToUpperCase1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("ABCDEFGHIJKLMNOPQRSTUVWXYZ")), Evaluator
.evaluate("toUpperCase('ABCDEFGHIJKLMNOPQRSTUVWXYZ')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testToUpperCase2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("1234567890.!\"Â§$%&/()=?")),
Evaluator.evaluate("toUpperCase('1234567890.!\"Â§$%&/()=?')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testToUpperCase3() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("ABCDEFGHIJKLMNOPQRSTUVWXYZ")), Evaluator
.evaluate("toUpperCase('abcdefghijklmnopqrstuvwxyz')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testToUpperCase4() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("")),
Evaluator.evaluate("toUpperCase('')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testToUpperCase5() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR(" ")),
Evaluator.evaluate("toUpperCase(' ')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testToUpperCaseWithInput1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("HELLO")),
Evaluator.evaluate("toUpperCase('[pos=7]')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testToUpperCaseWithInput2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("HELLO3")),
Evaluator.evaluate("toUpperCase('[pos=8]')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void TestToUpperCaseWithVariables1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("HELLO")),
Evaluator.evaluate("toUpperCase('[var=g]')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void TestToUpperCaseWithVariables2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("HELLO3")),
Evaluator.evaluate("toUpperCase('[var=h]')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testToUpperCaseWithExpressions1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("A")),
Evaluator.evaluate("toUpperCase(toUpperCase('a'))", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testToUpperCaseWithExpressions2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("A")), Evaluator
.evaluate("toUpperCase(toUpperCase(toUpperCase('a')))", exerciseVariableMap, fillInVariableMap));
}

@Test(expected = ParserException.class)
public void testToUpperCaseWithWrongInputCharacter() {
Evaluator.evaluate("toUpperCase(ab)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testToUpperCaseWithTwoArguments() {
Evaluator.evaluate("toUpperCase('A', 'B')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testToUpperCaseWithThreeArguments() {
Evaluator.evaluate("toUpperCase('A', 'B', 'C')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testToUpperCaseWithMissingExerciseVariable() {
Evaluator.evaluate("toUpperCase('[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testToUpperCaseWithMissingInput() {
Evaluator.evaluate("toUpperCase('[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

ToRadian

2017-09-19T06:47:18Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===

Die Funktion ''toRadians'' wandelt Grad-Werte in Radiant um. Die Funktion erwartet einen Grad-Wert und gibt den entsprechenden Radiant zurück.

=== Syntax ===
toRadians(float grad)

=== Parameter ===
* '''grad''' - der umzuwandelnde Grad-Wert

=== Return Value ===
*Gibt den Grad-Wert als Radiant zurück

=== Beispiele ===
==== Standardfälle ====
toRadians(180) --> returns 3.14159
toRadians(360) --> returns 6.28319

==== Benutzung mit Variablen ====
toRadians([pos=1])
toRadians([var=a])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
private static double PI = Math.PI;

@BeforeClass
public static void beforeTest() {
OMOBJ to180 = new OMOBJ();
OMOBJ zero = new OMOBJ();
to180.setOMI(OMCreator.createOMI(180));
zero.setOMI(OMCreator.createOMI(0));

fillIn.put(1, to180);
fillIn.put(2, zero);

exerVar.put("a", to180);
exerVar.put("b", zero);
}

@Test
public void testToRadians1() {
assertEquals(PI, Evaluator.getNumberResult("toRadians(180)", exerVar, fillIn), 0);
}

@Test
public void testToRadians2() {
assertEquals(2 * PI, Evaluator.getNumberResult("toRadians(360)", exerVar, fillIn), 0);
}

@Test
public void testToRadians3() {
assertEquals(3 * PI, Evaluator.getNumberResult("toRadians(540)", exerVar, fillIn), 0);
}

@Test
public void testToRadians4() {
assertEquals(PI / 2, Evaluator.getNumberResult("toRadians(90)", exerVar, fillIn), 0);
}

@Test
public void testToRadians5() {
assertEquals(-PI, Evaluator.getNumberResult("toRadians(-180)", exerVar, fillIn), 0);
}

@Test
public void testToRadians6() {
assertEquals(0, Evaluator.getNumberResult("toRadians(0)", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithInput1() {
assertEquals(PI, Evaluator.getNumberResult("toRadians('[pos=1]')", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithInput2() {
assertEquals(0, Evaluator.getNumberResult("toRadians('[pos=2]')", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithVariables1() {
assertEquals(PI, Evaluator.getNumberResult("toRadians('[var=a]')", exerVar, fillIn), 0);

}

@Test
public void testToRadiansWithVariables2() {
assertEquals(0, Evaluator.getNumberResult("toRadians('[var=b]')", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithPointNumbers1() {
assertEquals((PI * .2) / 180, Evaluator.getNumberResult("toRadians(0.2)", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithPointNumbers2() {
assertEquals((-PI * .1) / 180, Evaluator.getNumberResult("toRadians(-0.1)", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithExpressions1() {
assertEquals(0, Evaluator.getNumberResult("toRadians(toRadians(0))", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithExpressions2() {
assertEquals(0, Evaluator.getNumberResult("toRadians(toRadians(toRadians(0)))", exerVar, fillIn), 0);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testToRadiansWithWrongInputCharacter() {
Evaluator.getNumberResult("toRadians(a)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testToRadiansWithTwoArguments() {
Evaluator.getNumberResult("toRadians(180, 90)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testToRadiansWithThreeArguments() {
Evaluator.getNumberResult("toRadians(45, 90, 180)", exerVar, fillIn);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testToRadiansWithMissingExerciseVariable() {
Evaluator.getNumberResult("toRadians('[var=j]')", exerVar, fillIn);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testToRadiansWithMissingInput() {
Evaluator.getNumberResult("toRadians('[pos=42]')", exerVar, fillIn);
}

</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

ToLowerCase

2017-09-19T06:46:57Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''toLowerCase'' wandelt alle Buchstaben von a-z, A-Z einer Zeichenkette in Kleinbuchstaben um. Die Funktion erwartet einen String und gibt einen String zurück.

=== Syntax ===
toLowerCase(String zeichenkette)

===Parameter ===
* '''zeichenkette''' - die Zeichenkette, in der alle Buchstaben in Großbuchstaben umgewandelt werden sollen

=== Return Value ===
* Gibt einen String zurück

=== Beispiele ===
====Standardfälle====
toLowerCase('ICH BIN GROSS') --> returns 'ich bin gross'
toLowerCase('ABCDEFGHIJKLMNOPQRSTUVWXYZ') --> returns 'abcdefghijklmnopqrstuvwxyz'
toLowerCase('1234567890.!\"§$%&/()=?') --> returns '1234567890.!\"§$%&/()=?'

==== Benutzung mit Variablen ====
toLowerCase('[pos=1]')
toLowerCase('[var=a]')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(7, OMConverter.toObject("<OMOBJ><OMSTR>HELLO</OMSTR></OMOBJ>"));
fillInVariableMap.put(8, OMConverter.toObject("<OMOBJ><OMSTR>HELLO3</OMSTR></OMOBJ>"));

exerciseVariableMap.put("g", OMConverter.toObject("<OMOBJ><OMSTR>HELLO</OMSTR></OMOBJ>"));
exerciseVariableMap.put("h", OMConverter.toObject("<OMOBJ><OMSTR>HELLO3</OMSTR></OMOBJ>"));

}

@Test public void testToLowerCase1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("abcdefghijklmnopqrstuvwxyz")), Evaluator.evaluate("toLowerCase('ABCDEFGHIJKLMNOPQRSTUVWXYZ')", exerciseVariableMap, fillInVariableMap));
}

@Test public void testToLowerCase2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("1234567890.!\"Â§$%&/()=?")), Evaluator.evaluate("toLowerCase('1234567890.!\"Â§$%&/()=?')", exerciseVariableMap, fillInVariableMap));
}

@Test public void testToLowerCase3() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("abcdefghijklmnopqrstuvwxyz")), Evaluator.evaluate("toLowerCase('abcdefghijklmnopqrstuvwxyz')", exerciseVariableMap, fillInVariableMap));
}

@Test public void testToLowerCase4() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("")), Evaluator.evaluate("toLowerCase('')", exerciseVariableMap, fillInVariableMap));
}

@Test public void testToLowerCase5() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR(" ")), Evaluator.evaluate("toLowerCase(' ')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testToLowerCaseWithInput1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("hello")), Evaluator.evaluate("toLowerCase('[pos=7]')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testToLowerCaseWithInput2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("hello3")), Evaluator.evaluate("toLowerCase('[pos=8]')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void TestToLowerCaseWithVariables1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("hello")), Evaluator.evaluate("toLowerCase('[var=g]')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void TestToLowerCaseWithVariables2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("hello3")), Evaluator.evaluate("toLowerCase('[var=h]')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testToLowerCaseWithExpressions1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("a")), Evaluator.evaluate("toLowerCase(toLowerCase('A'))", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testToLowerCaseWithExpressions2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("a")), Evaluator.evaluate("toLowerCase(toLowerCase(toLowerCase('A')))", exerciseVariableMap, fillInVariableMap));
}

@Test(expected=ParserException.class)
public void testToLowerCaseWithWrongInputCharacter() {
Evaluator.evaluate("toLowerCase(ab)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidNumberOfArgumentsException.class)
public void testToLowerCaseWithTwoArguments() {
Evaluator.evaluate("toLowerCase('A', 'B')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidNumberOfArgumentsException.class)
public void testToLowerCaseWithThreeArguments() {
Evaluator.evaluate("toLowerCase('A', 'B', 'C')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=UndefinedExerciseVariableException.class)
public void testToLowerCaseWithMissingExerciseVariable() {
Evaluator.evaluate("toLowerCase('[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=UndefinedFillInVariableException.class)
public void testToLowerCaseWithMissingInput() {
Evaluator.evaluate("toLowerCase('[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

ToLowerCase

2017-09-19T06:46:33Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''toLowerCase'' wandelt alle Buchstaben von a-z, A-Z einer Zeichenkette in Kleinbuchstaben um. Die Funktion erwartet einen String und gibt einen String zurück.

=== Syntax ===
toLowerCase(String zeichenkette)

===Parameter ===
* '''zeichenkette''' - die Zeichenkette, in der alle Buchstaben in Großbuchstaben umgewandelt werden sollen

=== Return Value ===
* Gibt einen String zurück

=== Beispiele ===
====Standardfälle====
toLowerCase('ICH BIN GROSS') --> returns 'ich bin gross'
toLowerCase('ABCDEFGHIJKLMNOPQRSTUVWXYZ') --> returns 'abcdefghijklmnopqrstuvwxyz'
toLowerCase('1234567890.!\"§$%&/()=?') --> returns '1234567890.!\"§$%&/()=?'

==== Benutzung mit Variablen ====
toLowerCase('[pos=1]')
toLowerCase('[var=a]')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
private static double PI = Math.PI;

@BeforeClass
public static void beforeTest() {
OMOBJ to180 = new OMOBJ();
OMOBJ zero = new OMOBJ();
to180.setOMI(OMCreator.createOMI(180));
zero.setOMI(OMCreator.createOMI(0));

fillIn.put(1, to180);
fillIn.put(2, zero);

exerVar.put("a", to180);
exerVar.put("b", zero);
}

@Test
public void testToRadians1() {
assertEquals(PI, Evaluator.getNumberResult("toRadians(180)", exerVar, fillIn), 0);
}

@Test
public void testToRadians2() {
assertEquals(2 * PI, Evaluator.getNumberResult("toRadians(360)", exerVar, fillIn), 0);
}

@Test
public void testToRadians3() {
assertEquals(3 * PI, Evaluator.getNumberResult("toRadians(540)", exerVar, fillIn), 0);
}

@Test
public void testToRadians4() {
assertEquals(PI / 2, Evaluator.getNumberResult("toRadians(90)", exerVar, fillIn), 0);
}

@Test
public void testToRadians5() {
assertEquals(-PI, Evaluator.getNumberResult("toRadians(-180)", exerVar, fillIn), 0);
}

@Test
public void testToRadians6() {
assertEquals(0, Evaluator.getNumberResult("toRadians(0)", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithInput1() {
assertEquals(PI, Evaluator.getNumberResult("toRadians('[pos=1]')", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithInput2() {
assertEquals(0, Evaluator.getNumberResult("toRadians('[pos=2]')", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithVariables1() {
assertEquals(PI, Evaluator.getNumberResult("toRadians('[var=a]')", exerVar, fillIn), 0);

}

@Test
public void testToRadiansWithVariables2() {
assertEquals(0, Evaluator.getNumberResult("toRadians('[var=b]')", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithPointNumbers1() {
assertEquals((PI * .2) / 180, Evaluator.getNumberResult("toRadians(0.2)", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithPointNumbers2() {
assertEquals((-PI * .1) / 180, Evaluator.getNumberResult("toRadians(-0.1)", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithExpressions1() {
assertEquals(0, Evaluator.getNumberResult("toRadians(toRadians(0))", exerVar, fillIn), 0);
}

@Test
public void testToRadiansWithExpressions2() {
assertEquals(0, Evaluator.getNumberResult("toRadians(toRadians(toRadians(0)))", exerVar, fillIn), 0);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testToRadiansWithWrongInputCharacter() {
Evaluator.getNumberResult("toRadians(a)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testToRadiansWithTwoArguments() {
Evaluator.getNumberResult("toRadians(180, 90)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testToRadiansWithThreeArguments() {
Evaluator.getNumberResult("toRadians(45, 90, 180)", exerVar, fillIn);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testToRadiansWithMissingExerciseVariable() {
Evaluator.getNumberResult("toRadians('[var=j]')", exerVar, fillIn);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testToRadiansWithMissingInput() {
Evaluator.getNumberResult("toRadians('[pos=42]')", exerVar, fillIn);
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

ToDegree

2017-09-19T06:46:03Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===

Die Funktion ''toDegrees'' wandelt Radiant-Werte in Grad um. Die Funktion erwartet einen Radiant und gibt den entsprechenden Grad zurück.

=== Syntax ===
toDegrees(float radiant)

=== Parameter ===
* '''radiant''' - der umzuwandelnde Radiant-Wert

=== Return Value ===
*Gibt den Radiant-Wert in Grad zurück

=== Beispiele ===
==== Standardfälle ====
toDegrees(3.14159) --> returns 180
toDegrees(6.28319) --> returns 360

==== Benutzung mit Variablen ====
toDegrees([pos=1])
toDegrees([var=a])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
OMOBJ piFourth = new OMOBJ();
OMOBJ piHalf = new OMOBJ();
OMOBJ pi = new OMOBJ();
OMOBJ twoPi = new OMOBJ();
OMOBJ one = new OMOBJ();
piFourth.setOMF(OMCreator.createOMF(PI / 4));
piHalf.setOMF(OMCreator.createOMF(PI / 2));
pi.setOMF(OMCreator.createOMF(PI));
twoPi.setOMF(OMCreator.createOMF(2 * PI));
one.setOMI(OMCreator.createOMI(1));

fillIn.put(45, piFourth);
fillIn.put(90, piHalf);
fillIn.put(1, one);

exerVar.put("degc", pi);
exerVar.put("degd", twoPi);
exerVar.put("b", one);
}

@Test
public void testToDegrees1() {
assertEquals(540, Evaluator.getNumberResult("toDegrees(" + 3 * PI + ")", exerVar, fillIn), 0);
}

@Test
public void testToDegrees2() {
assertEquals(360, Evaluator.getNumberResult("toDegrees(" + 2 * PI + ")", exerVar, fillIn), 0);
}

@Test
public void testToDegrees3() {
assertEquals(180, Evaluator.getNumberResult("toDegrees(" + PI + ")", exerVar, fillIn), 0);
}

@Test
public void testToDegrees4() {
assertEquals(-180, Evaluator.getNumberResult("toDegrees(" + -PI + ")", exerVar, fillIn), 0);
}

@Test
public void testToDegrees5() {
assertEquals(90, Evaluator.getNumberResult("toDegrees(" + PI / 2 + ")", exerVar, fillIn), 0);
}

@Test
public void testToDegrees6() {
assertEquals(45, Evaluator.getNumberResult("toDegrees(" + PI / 4 + ")", exerVar, fillIn), 0);
}

@Test
public void testToDegrees7() {
assertEquals(180 / PI, Evaluator.getNumberResult("toDegrees(1)", exerVar, fillIn), 0);
}

@Test
public void testToDegreesWithInput1() {
assertEquals(90, Evaluator.getNumberResult("toDegrees('[pos=90]')", exerVar, fillIn), 0);
}

@Test
public void testToDegreesWithInput2() {
assertEquals(45, Evaluator.getNumberResult("toDegrees('[pos=45]')", exerVar, fillIn), 0);
}

@Test
public void testToDegreesWithInput3() {
assertEquals(180 / PI, Evaluator.getNumberResult("toDegrees('[pos=1]')", exerVar, fillIn), 0);
}

@Test
public void testToDegreesWithVariables1() {
assertEquals(360, Evaluator.getNumberResult("toDegrees('[var=degd]')", exerVar, fillIn), 0);
}

@Test
public void testToDegreesWithVariables2() {
assertEquals(180, Evaluator.getNumberResult("toDegrees('[var=degc]')", exerVar, fillIn), 0);
}

@Test
public void testToDegreesWithVariables3() {
assertEquals(180 / PI, Evaluator.getNumberResult("toDegrees('[var=b]')", exerVar, fillIn), 0);
}

@Test
public void testToDegreesWithVariables4() {
assertEquals(180, Evaluator.getNumberResult("toDegrees('[var=PI]')", exerVar, fillIn), 0);
}

@Test
public void testToDegreesWithPointNumbers1() {
assertEquals(.2 * 180 / (PI), Evaluator.getNumberResult("toDegrees(0.2)", exerVar, fillIn), 0);
}

@Test
public void testToDegreesWithPointNumbers2() {
assertEquals(.1 * 180 / (-PI), Evaluator.getNumberResult("toDegrees(-0.1)", exerVar, fillIn), 0);
}

@Test
public void testToDegreesWithExpressions1() {
assertEquals(0, Evaluator.getNumberResult("toDegrees(toDegrees(0))", exerVar, fillIn), 0);
}

@Test
public void testToDegreesWithExpressions2() {
assertEquals(0, Evaluator.getNumberResult("toDegrees(toDegrees(toDegrees(0)))", exerVar, fillIn), 0);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testToDegreesWithWrongInputCharacter() {
Evaluator.getNumberResult("toDegrees(a)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testToDegreesWithTwoArguments() {
Evaluator.getNumberResult("toDegrees(4, 3)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testToDegreesWithThreeArguments() {
Evaluator.getNumberResult("toDegrees(2, 3, 4)", exerVar, fillIn);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testToDegreesWithMissingExerciseVariable() {
Evaluator.getNumberResult("toDegrees('[var=j]')", exerVar, fillIn);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testToDegreesWithMissingInput() {
Evaluator.getNumberResult("toDegrees('[pos=42]')", exerVar, fillIn);
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

Tan

2017-09-19T06:45:42Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Der Tangens wird durch die Funktion ''tan'' beschrieben. Sie erwartet einen Parameter und gibt einen Wert zurück.

===Syntax===
tan(String zeichenkette)

===Parameter===
* '''zeichenkette''' - ein Wert im Bogenmaß

===Return Value===
* Gibt den Wert des Tangens an der Stelle zurück.

===Beispiele===
tan('Pi/4') --> returns 1

tan('0') --> 0

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
fillInVariableMap.put(2, OMCreator.createOMOBJ(OMSymbol.NUMS1_PI));
}

@Test
public void testTan1() {
assertEquals(0, Evaluator.getNumberResult("tan('0')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testTan2() {
assertEquals(0, Evaluator.getNumberResult("tan('[var=PI]')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testTan3() {
assertEquals(0, Evaluator.getNumberResult("tan('-[var=PI]')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testTan4() {
assertEquals(1, Evaluator.getNumberResult("tan('[var=PI]/4')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testTan5() {
assertEquals(-1, Evaluator.getNumberResult("tan('-[var=PI]/4')", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testTanWithInput1() {
assertEquals(0, Evaluator.getNumberResult("tan('[pos=1]')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testTanWithInput2() {
assertEquals(1, Evaluator.getNumberResult("tan('[pos=2]/4')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testTanWithVariables1() {
assertEquals(0, Evaluator.getNumberResult("tan('[var=a]')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testTanWithVariables2() {
assertEquals(1, Evaluator.getNumberResult("tan('[var=PI]/4')", exerciseVariableMap, fillInVariableMap), 0.0001); // Rounding
// Error
}

@Test
public void testTanWithExpressions1() {
assertEquals(0, Evaluator.getNumberResult("tan(tan(0))", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testTanWithExpressions2() {
assertEquals(0, Evaluator.getNumberResult("tan(tan(tan(0)))", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testTanWithONECharacter() {
Evaluator.getNumberResult("tan(a)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testTanWithEmptyStringArgument() {
Evaluator.getNumberResult("tan('')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testTanWithEmptyArgument() {
Evaluator.getNumberResult("tan()", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testTanWithoutExerciseVariable() {
Evaluator.getNumberResult("tan('[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testTanWithoutInput() {
Evaluator.getNumberResult("tan('[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===
* Berechnet nur den Tangens mit Werten im Bogenmaß. Der Gradmaß muss ggf. vorher umgewandelt werden.

[[Kategorie:Evaluatorfunktion]]

Substring

2017-09-19T06:43:38Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''Substring'' gibt anhand des Anfangs- und der Endposition eine Zeichenkette aus einer übergebenen Zeichenkette zurück. Die Funktion erwartet einen Zeichenkette aus der eine Zeichenkette extrahiert werden soll und jeweils eine Zahl für die Anfangs- und die Endposition. Die Werte der Positionen dürfen nicht geringer als 0 und nicht größer als die Länge der übergebenen Zeichenkette sein. Es wird die extrahierte Zeichenkette zurück gegeben.

=== Syntax ===
substring(String zeichenkette, int anfangsPosition, int endPosition)

===Parameter ===
* '''zeichenkette''' - die Zeichenkette aus der eine Zeichenkette extrahiert werde soll.
* '''anfangsPosition''' - die Position des ersten Zeichens in der Zeichenkette, ab dem extrahiert werden soll.
* '''endPosition''' - die Position+1 des letzten Zeichen, bis zu dem extrahiert werden soll.

=== Return Value ===
* Gibt einen String zurück

=== Beispiele ===
====Standardfälle====
substring('hello world',0,5) --> returns 'hello'
substring('hello world',6,11) --> returns 'world'

==== Benutzung mit Variablen ====
substring('[pos=1]',0,5)
substring('[var=a]',6,11)

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(7, OMConverter.toObject("<OMOBJ><OMSTR>helloworld</OMSTR></OMOBJ>"));
fillInVariableMap.put(8, OMConverter.toObject("<OMOBJ><OMI>0</OMI></OMOBJ>"));
fillInVariableMap.put(9, OMConverter.toObject("<OMOBJ><OMI>5</OMI></OMOBJ>"));

exerciseVariableMap.put("suba", OMConverter.toObject("<OMOBJ><OMSTR>helloworld</OMSTR></OMOBJ>"));
exerciseVariableMap.put("g", OMConverter.toObject("<OMOBJ><OMI>0</OMI></OMOBJ>"));
exerciseVariableMap.put("h", OMConverter.toObject("<OMOBJ><OMI>5</OMI></OMOBJ>"));

}

@Test
public void testSubstring1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("hello")),
Evaluator.evaluate("substring('hello world', 0, 5)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testSubstring2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("world")),
Evaluator.evaluate("substring('hello world', 6, 11)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testSubstring3() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR(" ")),
Evaluator.evaluate("substring('hello world', 5, 6)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testSubstring4() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("a")),
Evaluator.evaluate("substring('abcde', 0, 1)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testSubstring5() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("e")),
Evaluator.evaluate("substring('abcde', 4, 5)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testSubstring6() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("")),
Evaluator.evaluate("substring('abcde', 4, 4)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testSubstring7() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("e")),
Evaluator.evaluate("substring('abcde', 4.0, 5)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testSubstringWithInput1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("orld")),
Evaluator.evaluate("substring('[pos=7]', 6, 10)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testSubstringWithInput2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("a")),
Evaluator.evaluate("substring('abcde', [pos=8], 1)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testSubstringWithInput3() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("e")),
Evaluator.evaluate("substring('abcde', 4, [pos=9])", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testSubstringWithVariables1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("orld")),
Evaluator.evaluate("substring('[var=suba]', 6, 10)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testSubstringWithVariables2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("a")),
Evaluator.evaluate("substring('abcde', [var=g], 1)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testSubstringWithVariables3() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("e")),
Evaluator.evaluate("substring('abcde', 4, [var=h])", exerciseVariableMap, fillInVariableMap));
}

@Test(expected = FunctionInvalidArgumentException.class)
public void testSubstringWithWrongInputSecondAndThirdArgument() {
Evaluator.evaluate("substring('hello', -1, 6)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testSubstringWithWrongInputSecondArgumentAsPointNumber() {
OMSTR result = Evaluator.evaluate("substring('hello', 1.3, 2)", exerciseVariableMap, fillInVariableMap).getOMSTR();
assertEquals("<OMSTR>e</OMSTR>",result.toString());

}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testSubstringWithWrongInputThirdArgumentAsPointNumber() {
OMSTR result = Evaluator.evaluate("substring('hello', 1, 2.9)", exerciseVariableMap, fillInVariableMap).getOMSTR();
assertEquals("<OMSTR>e</OMSTR>",result.toString());
}

@Test(expected = ParserException.class)
public void testSubstringWithWrongInputCharacter() {
Evaluator.evaluate("substring(ab, ab, ab)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testSubstringWithOneArgument() {
Evaluator.evaluate("substring('hello')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test
public void testSubstringWithTwoArguments() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("llo")),
Evaluator.evaluate("substring('hello', 2)", exerciseVariableMap, fillInVariableMap));
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testSubstringWithMissingExerciseVariable() {
Evaluator.evaluate("substring('[var=j]', '[var=j]', '[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testSubstringWithMissingInput() {
Evaluator.evaluate("substring('[pos=42]', '[pos=42]', '[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===
* Die Position 0 ist das erste Zeichen, nicht Position 1

[[Kategorie:Evaluatorfunktion]]

StartsWith

2017-09-19T06:43:15Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''StartsWith'' prüft, ob eine Zeichenkette ab einer bestimmten Position mit einer bestimmen Zeichenkette anfängt. Die Funktion erwartet eine zu prüfende Zeichenkette, eine Zeichenkette die gesucht wird und eine Position, ab der geprüft werden soll. Fängt an der gegebenen Position die gesuchte Zeichenkette in der zu prüfenden Zeichenkette an, liefert die Funktion true zurück, ansonsten false

=== Syntax ===
startsWith(String zeichenkette, String gesuchterString, String startPosition)

===Parameter ===
* '''zeichenkette''' - die Zeichenkette, die geprüft werden soll,
* '''gesuchterString''' - die Zeichenkette, auf dessen vorkommen geprüft wird,
* '''startPosition''' - der Postion ab der überprüft wird

=== Return Value ===
* Gibt einen Boolean-Wert zurück

=== Beispiele ===
====Standardfälle====
startsWith('hello','he',0) --> returns true
startsWith('hier klappt es nicht','hello',10) --> returns false
==== Benutzung mit Variablen ====
startsWith('[pos=1]','test',0)
startsWith('[var=a]','o',4)

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(7, OMConverter.toObject("<OMOBJ><OMSTR>ll</OMSTR></OMOBJ>"));
fillInVariableMap.put(8, OMConverter.toObject("<OMOBJ><OMI>0</OMI></OMOBJ>"));
fillInVariableMap.put(9, OMConverter.toObject("<OMOBJ><OMSTR>hello</OMSTR></OMOBJ>"));

exerciseVariableMap.put("g", OMConverter.toObject("<OMOBJ><OMI>0</OMI></OMOBJ>"));
exerciseVariableMap.put("ll", OMConverter.toObject("<OMOBJ><OMSTR>ll</OMSTR></OMOBJ>"));
exerciseVariableMap.put("hello", OMConverter.toObject("<OMOBJ><OMSTR>hello</OMSTR></OMOBJ>"));

}

@Test
public void testStartsWith1() {
assertTrue(Evaluator.getBooleanResult("startsWith('hello','he',0)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testStartsWith2() {
assertTrue(Evaluator.getBooleanResult("startsWith('hello','ll',2)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testStartsWith3() {
assertTrue(Evaluator.getBooleanResult("startsWith('hello','o',4)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testStartsWith4() {
assertTrue(!Evaluator.getBooleanResult("startsWith('hello','ll',0)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testStartsWith5() {
assertTrue(Evaluator.getBooleanResult("startsWith('','',0)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testStartsWith6() {
assertTrue(!Evaluator.getBooleanResult("startsWith('',' ',0)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testStartsWithInput1() {
assertTrue(
Evaluator.getBooleanResult("startsWith('hello','he',[pos=8])", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testStartsWithInput2() {
assertTrue(
Evaluator.getBooleanResult("startsWith('hello','[pos=7]',2)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testStartsWithInput3() {
assertTrue(Evaluator.getBooleanResult("startsWith('[pos=9]','o',4)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testStartsWithVariables1() {
assertTrue(
Evaluator.getBooleanResult("startsWith('hello','he',[var=g])", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testStartsWithVariables2() {
assertTrue(
Evaluator.getBooleanResult("startsWith('hello','[var=ll]',2)", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testStartsWithVariables3() {
assertTrue(
Evaluator.getBooleanResult("startsWith('[var=hello]','o',4)", exerciseVariableMap, fillInVariableMap));
}

@Test(expected = ParserException.class)
public void testStartsWithWithWrongInputCharacter() {
Evaluator.getBooleanResult("startsWith(ab)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testStartsWithWithOneArgument() {
Evaluator.getBooleanResult("startsWith('hello')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test
public void testStartsWithWithTwoArguments() {
Evaluator.getBooleanResult("startsWith('hello', 'he')", exerciseVariableMap, fillInVariableMap);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testStartsWithWithMissingExerciseVariable() {
Evaluator.getBooleanResult("startsWith('[var=j]', '[var=j]', '[var=j]')", exerciseVariableMap,
fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testStartsWithWithMissingInput() {
Evaluator.getBooleanResult("startsWith('[pos=42]', '[pos=42]', '[pos=42]')", exerciseVariableMap,
fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

Sin

2017-09-19T06:42:44Z

Mbuttgereit:

===Beschreibung===
Der Sinus wird durch die ''sin''-Funktion beschrieben. Sie erwartet einen Parameter und gibt einen Wert zurück.

===Syntax===
sin(String zeichenkette)

===Parameter===
* '''zeichenkette''' - ein Wert im Bogenmaß

===Return Value===
* Der Rückgabewert der Sinusfunktion.

===Beispiele===
sin('Pi') --> returns 0

sin('Pi/2') --> returns 1

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
fillInVariableMap.put(2, OMCreator.createOMOBJ(OMSymbol.NUMS1_PI));
}

@Test
public void testSin1() {
assertEquals(0, Evaluator.getNumberResult("sin('0')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testSin2() {
assertEquals(1, Evaluator.getNumberResult("sin('[var=PI]/2')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testSin3() {
assertEquals(-1, Evaluator.getNumberResult("sin('-[var=PI]/2')", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testSin4() {
assertEquals(0, Evaluator.getNumberResult("sin('[var=PI]')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testSin5() {
assertEquals(0, Evaluator.getNumberResult("sin('-[var=PI]')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testSinWithInput1() {
assertEquals(0, Evaluator.getNumberResult("sin('[pos=1]')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testSinWithInput2() {
assertEquals(1, Evaluator.getNumberResult("sin('[pos=2]/2')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testSinWithVariables1() {
assertEquals(0, Evaluator.getNumberResult("sin('[var=a]')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testSinWithVariables2() {
assertEquals(1, Evaluator.getNumberResult("sin('[var=PI]/2')", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testSinWithExpressions1() {
assertEquals(0, Evaluator.getNumberResult("sin(sin(0))", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testSinWithExpressions2() {
assertEquals(0, Evaluator.getNumberResult("sin(sin(sin(0)))", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testSinWithONECharacter() {
Evaluator.getNumberResult("sin(a)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testSinWithEmptyStringArgument() {
Evaluator.getNumberResult("sin('')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testSinWithEmptyArgument() {
Evaluator.getNumberResult("sin()", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testSinWithoutExerciseVariable() {
Evaluator.getNumberResult("sin('[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testSinWithoutInput() {
Evaluator.getNumberResult("sin('[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===
* Die Funktion braucht den Wert im Bogenmaß, ggf. muss man den Gradmaß vorher umrechnen.

[[Kategorie:Evaluatorfunktion]]

Set

2017-09-19T06:42:20Z

Mbuttgereit:

===Beschreibung===
Die Funktion ''set'' bekommt als Eingabe Mengenelemente und gibt diese als OpenMathObject zurück.

===Syntax===
set(string argument, string argument, ...)

===Parameter===
* '''argument''' - beliebig viele strings für die einzelnen Mengenelemente

===Return Value===
* Gibt die Menge als OpenMathObject zurück

===Beispiele===
set(vector(1,1),vector(1,2)) --> <OMOBJ><OMA><OMS cd="list1" name="list"/><OMA><OMS cd="linalg2" name="vector"/><OMI>1</OMI><OMI>1</OMI></OMA><OMA><OMS cd="linalg2" name="vector"/><OMI>1</OMI><OMI>2</OMI></OMA></OMA></OMOBJ>

<math>\{ \begin{pmatrix} 1 \\ 1 \end{pmatrix} , \begin{pmatrix} 1 \\ 2 \end{pmatrix} \}</math>

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@Test
public void testSet() {
assertEquals(ExpressionParser.parse("set(vector(1,1), vector(1,2))", exerciseVariableMap, fillInVariableMap),
Evaluator.evaluate("set(vector(1,1), vector(1,2))", exerciseVariableMap, fillInVariableMap));
}
</syntaxhighlight>

===Hinweise===
* Die Funktion setzt eine Menge von Elementen in die OpenMath schreibweise.

[[Kategorie:Evaluatorfunktion]]

Round

2017-09-19T06:40:34Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===

Die Funktion ''round'' rundet eine Gleitkommazahl zu einer Ganzzahl. Die Funktion erwartet eine Zahl und gibt die nächst gelegene Ganzzahl zurück.

=== Syntax ===
round(float zahl)

=== Parameter ===
* '''zahl''' - die zu rundene Zahl

=== Return Value ===
*Gibt die gerundete Ganzzahl zurück

=== Beispiele ===
==== Standardfälle ====
round(12.4) --> returns 12
round(15.678) --> returns 16

==== Benutzung mit Variablen ====
round([pos=1])
round([var=a])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
OMOBJ nineThree = new OMOBJ();
OMOBJ threeFive = new OMOBJ();
nineThree.setOMF(OMCreator.createOMF(93.49999));
threeFive.setOMF(OMCreator.createOMF(3.5));

fillIn.put(4, threeFive);
fillIn.put(93, nineThree);

exerVar.put("a", threeFive);
exerVar.put("b", nineThree);
}

@Test
public void testRound1() {
assertEquals(6, Evaluator.getNumberResult("round(6.3)", exerVar, fillIn), 0);
}

@Test
public void testRound2() {
assertEquals(93, Evaluator.getNumberResult("round(93.49999)", exerVar, fillIn), 0);
}

@Test
public void testRound3() {
assertEquals(94, Evaluator.getNumberResult("round(93.50001)", exerVar, fillIn), 0);
}

@Test
public void testRound4() {
assertEquals(-93, Evaluator.getNumberResult("round(-93.49999)", exerVar, fillIn), 0);
}

@Test
public void testRound5() {
assertEquals(-94, Evaluator.getNumberResult("round(-93.50001)", exerVar, fillIn), 0);
}

@Test
public void testRound6() {
assertEquals(4, Evaluator.getNumberResult("round(3.5)", exerVar, fillIn), 0);
}

@Test
public void testRound7() {
assertEquals(3, Evaluator.getNumberResult("round(2.5)", exerVar, fillIn), 0);
}

@Test
public void testRoundWithInput1() {
assertEquals(4, Evaluator.getNumberResult("round([pos=4])", exerVar, fillIn), 0);
}

@Test
public void testRoundWithInput2() {
assertEquals(93, Evaluator.getNumberResult("round([pos=93])", exerVar, fillIn), 0);
}

@Test
public void testRoundWithVariable1() {
assertEquals(4, Evaluator.getNumberResult("round([var=a])", exerVar, fillIn), 0);
}

@Test
public void testRoundWithVariable2() {
assertEquals(93, Evaluator.getNumberResult("round([var=b])", exerVar, fillIn), 0);
}

@Test
public void testRoundWithPointNumbers1() {
assertEquals(0, Evaluator.getNumberResult("round(0.2)", exerVar, fillIn), 0);
}

@Test
public void testRoundWithPointNumbers2() {
assertEquals(0, Evaluator.getNumberResult("round(-0.2)", exerVar, fillIn), 0);
}

@Test
public void testRoundWithExpressions1() {
assertEquals(-2, Evaluator.getNumberResult("round(round(-2.2))", exerVar, fillIn), 0);
}

@Test
public void testRoundWithExpressions2() {
assertEquals(2, Evaluator.getNumberResult("round(round(round(2.1)))", exerVar, fillIn), 0);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testRoundWithWrongInputCharacter() {
Evaluator.getNumberResult("round(a)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testRoundWithTwoArguments() {
Evaluator.getNumberResult("round(1.2, 1.3)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testRoundWithThreeArguments() {
Evaluator.getNumberResult("round(2.1, 2.2, 2.3)", exerVar, fillIn);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testRoundWithMissingExerciseVariable() {
Evaluator.getNumberResult("round('[var=j]')", exerVar, fillIn);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testRoundWithMissingInput() {
Evaluator.getNumberResult("round('[pos=42]')", exerVar, fillIn);
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

Rint

2017-09-19T06:40:12Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===

Die Funktion ''rint'' ermittelt eine Ganzzahl, die am nächsten an der übergebenen Zahl liegt. Die Funktion erwartet eine Zahl und gibt die nächst gelegenen Ganzzahl zurück

=== Syntax ===
rint(float zahl)

=== Parameter ===
* '''zahl''' - die Zahl, zu der die naheliegenste Ganzzahl ermittelt werden soll

=== Return Value ===
*Gibt die naheliegenste Ganzzahl zurück

=== Beispiele ===
==== Standardfälle ====
rint(12.4) --> returns 12
rint(15.678) --> returns 16

==== Benutzung mit Variablen ====
rint([pos=1])
rint([var=a])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
OMOBJ obj1 = new OMOBJ();
OMOBJ obj2 = new OMOBJ();
OMOBJ obj3 = new OMOBJ();
OMOBJ obj4 = new OMOBJ();
obj1.setOMF(OMCreator.createOMF(50.33333));
obj2.setOMF(OMCreator.createOMF(99.993444));
obj3.setOMF(OMCreator.createOMF(5.49999));
obj4.setOMF(OMCreator.createOMF(1233.511111));

fillIn.put(5, obj3);
fillIn.put(1234, obj4);

exerVar.put("f1", obj1);
exerVar.put("h", obj2);
}

@Test
public void testRint1() {
assertEquals(12, Evaluator.getNumberResult("rint(12.4999)", exerVar, fillIn), 0);
}

@Test
public void testRint2() {
assertEquals(13, Evaluator.getNumberResult("rint(12.500001)", exerVar, fillIn), 0);
}

@Test
public void testRint3() {
assertEquals(12, Evaluator.getNumberResult("rint(12.5)", exerVar, fillIn), 0);
}

@Test
public void testRint4() {
assertEquals(14, Evaluator.getNumberResult("rint(13.5)", exerVar, fillIn), 0);
}

@Test
public void testRint5() {
assertEquals(-99, Evaluator.getNumberResult("rint(-99.4999)", exerVar, fillIn), 0);
}

@Test
public void testRint6() {
assertEquals(-100, Evaluator.getNumberResult("rint(-99.5999)", exerVar, fillIn), 0);
}

@Test
public void testRint7() {
assertEquals(0, Evaluator.getNumberResult("rint(-0.00001)", exerVar, fillIn), 0);
}

@Test
public void testRint8() {
assertEquals(0, Evaluator.getNumberResult("rint(0.00001)", exerVar, fillIn), 0);
}

@Test
public void testRintWithInput1() {
assertEquals(5, Evaluator.getNumberResult("rint([pos=5])", exerVar, fillIn), 0);
}

@Test
public void testRintWithInput2() {
assertEquals(1234, Evaluator.getNumberResult("rint([pos=1234])", exerVar, fillIn), 0);
}

@Test
public void testRintWithVariables1() {
assertEquals(50, Evaluator.getNumberResult("rint([var=f1])", exerVar, fillIn), 0);
}

@Test
public void testRintWithVariables2() {
assertEquals(100, Evaluator.getNumberResult("rint([var=h])", exerVar, fillIn), 0);
}

@Test
public void testRintWithPointNumbers1() {
assertEquals(0, Evaluator.getNumberResult("rint(0.2)", exerVar, fillIn), 0);

}

@Test
public void testRintWithPointNumbers2() {
assertEquals(0, Evaluator.getNumberResult("rint(-0.2)", exerVar, fillIn), 0);
}

@Test
public void testRintWithExpressions1() {
assertEquals(-2, Evaluator.getNumberResult("rint(rint(-2.2))", exerVar, fillIn), 0);
}

@Test
public void testRintWithExpressions2() {
assertEquals(2, Evaluator.getNumberResult("rint(rint(rint(2.1)))", exerVar, fillIn), 0);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testRintWithWrongInputCharacter() {
Evaluator.getNumberResult("rint(a)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testRintWithTwoArguments() {
Evaluator.getNumberResult("rint(4.2, 3.1)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testRintWithThreeArguments() {
Evaluator.getNumberResult("rint(2.1, 2.2, 2.3)", exerVar, fillIn);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testRintWithMissingExerciseVariable() {
Evaluator.getNumberResult("rint('[var=j]')", exerVar, fillIn);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testRintWithMissingInput() {
Evaluator.getNumberResult("rint('[pos=42]')", exerVar, fillIn);
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

Replace

2017-09-19T06:39:50Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''replace'' ersetzt alle entsprechenden Zeichen einer Zeichenkette durch ein angegebenes Zeichen. Die Funktion benötigt eine Zeichenkette, ein zu ersetzendes Zeichen und ein Zeichen, durch das alle zu ersetzende Zeichen in der Zeichenkette ausgetauscht werden.

=== Syntax ===
replace(String zeichenkette, Char zeichen, Char austauschZeichen)

===Parameter ===
* '''zeichenkette''' - die Zeichenkette, in der Zeichen ausgetausch werden sollen
* '''zeichen''' - das Zeichen, das ausgetauscht werden soll
* '''austauschZeichen''' - das Zeichen, durch das die anderen ausgetauscht werden.

=== Return Value ===
* Gibt einen String zurück

=== Beispiele ===
====Standardfälle====
replace('Hello World! ',' ','$') --> returns 'Hello$$World!$'
replace('Have a!nice day!','!',' ') --> returns 'Have a nice day '

==== Benutzung mit Variablen ====
repalce('[pos=1]','a','t')
replace('Hallo','[var=a]','a')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(7, OMConverter.toObject("<OMOBJ><OMSTR>HaveQaQniceQday</OMSTR></OMOBJ>"));
fillInVariableMap.put(8, OMConverter.toObject("<OMOBJ><OMSTR>a</OMSTR></OMOBJ>"));
fillInVariableMap.put(9, OMConverter.toObject("<OMOBJ><OMSTR>b</OMSTR></OMOBJ>"));

exerciseVariableMap.put("g", OMConverter.toObject("<OMOBJ><OMSTR>HaveQaQniceQday</OMSTR></OMOBJ>"));
exerciseVariableMap.put("h", OMConverter.toObject("<OMOBJ><OMSTR>a</OMSTR></OMOBJ>"));
exerciseVariableMap.put("i", OMConverter.toObject("<OMOBJ><OMSTR>b</OMSTR></OMOBJ>"));

}

@Test
public void testReplace1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("Hello$$World!$")),
Evaluator.evaluate("replace('Hello World! ', ' ', '$')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplace2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("Have a nice day ")),
Evaluator.evaluate("replace('Have a nice day!', '!', ' ')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplace3() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("1010101")),
Evaluator.evaluate("replace('a0a0a0a', 'a', '1')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplace4() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("`0`0`0`")),
Evaluator.evaluate("replace('a0a0a0a', 'a', '`')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplaceWithInput1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("Have a nice day")),
Evaluator.evaluate("replace('[pos=7]', 'Q', ' ')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplaceWithInput2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("H veQ QniceQd y")),
Evaluator.evaluate("replace('[pos=7]', '[pos=8]', ' ')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplaceWithInput3() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("HbveQbQniceQdby")),
Evaluator.evaluate("replace('[pos=7]', '[pos=8]', '[pos=9]')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplaceWithVariables1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("Have a nice day")),
Evaluator.evaluate("replace('[var=g]', 'Q', ' ')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplaceWithVariables2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("H veQ QniceQd y")),
Evaluator.evaluate("replace('[var=g]', '[var=h]', ' ')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplaceWithVariables3() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("HbveQbQniceQdby")),
Evaluator.evaluate("replace('[var=g]', '[var=h]', '[var=i]')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplaceWithCharacterMaxMinValue1() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("" + cMax + "0")),
Evaluator.evaluate("replace('a0', 'a', '" + cMax + "')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplaceWithCharacterMaxMinValue2() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("" + cMin + "0")),
Evaluator.evaluate("replace('a0', 'a', '" + cMin + "')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplaceWithWrongInputSecondArgumentEmpty() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("aaaaa")),
Evaluator.evaluate("replace('aa', '', 'a')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testReplaceWithThirdArgumentEmpty() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("a")),
Evaluator.evaluate("replace('a ', ' ', '')", exerciseVariableMap, fillInVariableMap));
}

@Test(expected = ParserException.class)
public void testReplaceWithWrongInputCharacter() {
Evaluator.evaluate("replace(ab, ab, ab)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testReplaceWithOneArgument() {
Evaluator.evaluate("replace('a')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testReplaceWithTwoArguments() {
Evaluator.evaluate("replace('a', 'b')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testReplaceWithMissingExerciseVariable() {
Evaluator.evaluate("replace('[var=j]', '[var=j]', '[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testReplaceWithMissingInput() {
Evaluator.evaluate("replace('[pos=42]', '[pos=42]', '[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

RandomMatrixRank

2017-09-19T06:39:20Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktion ''randomMatrixRank'' erzeugt zufällig eine Matrix in dem angegebenen Zahlenraum, der angegebenen Anzahl der Zeilen und Spalten, den angegebenen Rang und (optional) der angegebenen oberen Grenze für die Einträge.

===Syntax===
randomMatrixRank(String matrix, String zahl1, String zahl2, String zahl3, String zahl4)

===Parameter===
* '''matrix''' - Gibt an in welchen Zahlenraum die Matrix sein soll, z.B. 'ZZ' für ganze Zahlen und 'QQ' für rationale Zahlen.
* '''zahl1''' - Gibt die Anzahl der Zeilen n der nxm-Matrix an.
* '''zahl2''' - Gibt die Anzahl der Spalten m der nxm-Matrix an.
* '''zahl3''' - Gibt den Rang der Matrix an. Der Wert muss kleiner gleich m und n sein.
* '''zahl4''' - Gibt die obere Grenze für die Einträge an (optional), Beispiel: 10 -> [-10,10].

===Return Value===
* Gibt die Matrix als OpenMathObject zurück.

===Beispiele===
randomMatrixRank('QQ','2','2','2')

randomMatrixRank('QQ','3','4','3','7')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

randomMatrixRankFillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));

randomMatrixRankExerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));

}

@Test
public void testRandomMatrixEigenValue1() {
Evaluator.evaluate("randomMatrixRank('QQ', '3', '2', '2')", randomMatrixRankExerciseVariableMap, randomMatrixRankFillInVariableMap);
}

@Test
public void testRandomMatrixEigenValue2() {
Evaluator.evaluate("randomMatrixRank('QQ', '3', '3', '1')", randomMatrixRankExerciseVariableMap, randomMatrixRankFillInVariableMap);
}

@Test
public void testRandomMatrixEigenValue3() {
Evaluator.evaluate("randomMatrixRank('ZZ', '2', '2', '1', '2')", randomMatrixRankExerciseVariableMap, randomMatrixRankFillInVariableMap);
}

@Test
public void testRandomMatrixEigenValueWithInput() {
Evaluator.evaluate("randomMatrixRank('QQ', '[pos=1]', '2', '2')", randomMatrixRankExerciseVariableMap, randomMatrixRankFillInVariableMap);
}

@Test
public void testRandomMatrixEigenValueWithVariables() {
Evaluator.evaluate("randomMatrixRank('QQ', '[var=a]', '2', '2')", randomMatrixRankExerciseVariableMap, randomMatrixRankFillInVariableMap);
}

@Test(expected = ParserException.class)
public void testRandomMatrixEigenValueWithONECharacter() {
Evaluator.evaluate("randomMatrixRank(ab, ab, ab, ab)", randomMatrixRankExerciseVariableMap, randomMatrixRankFillInVariableMap);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testRandomMatrixEigenValueWithEmptyStringArgument() {
Evaluator.evaluate("randomMatrixRank('', '', '', '')", randomMatrixRankExerciseVariableMap, randomMatrixRankFillInVariableMap);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testRandomMatrixEigenValueWithEmptyArgument() {
Evaluator.evaluate("randomMatrixRank()", randomMatrixRankExerciseVariableMap, randomMatrixRankFillInVariableMap);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testRandomMatrixEigenValueWithoutExerciseVariable() {
Evaluator.evaluate("randomMatrixRank('[var=j]', '[var=j]', '[var=j]', '[var=j]')", randomMatrixRankExerciseVariableMap, randomMatrixRankFillInVariableMap);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testRandomMatrixEigenValueWithoutInput() {
Evaluator.evaluate("randomMatrixRank('[pos=42]', '[pos=42]', '[pos=42]', '[pos=42]')", randomMatrixRankExerciseVariableMap, randomMatrixRankFillInVariableMap);
}
</syntaxhighlight>

===Hinweise===
* Mit der Funktion [[evaluateInSage]] lassen sich die Eigenschaften der Matrix abfragen, z.B.
evaluateInSage('[var=Matrix].rank()') --> Gibt den Rang der Matrix zurück

[[Kategorie:Evaluatorfunktion]]

RandomMatrixEigenvalue

2017-09-19T06:38:56Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktion ''randomMatrixEigenvalue'' gibt eine diagonalisierbare Matrix zurück. Die Funktion wird in Sage bearbeitet. Sie braucht die Matrix, die Eigenwerte und die Dimension der jeweiligen Eigenräume als Eingabewerte und gibt die Matrix zurück.

===Syntax===
randomMatrixEigenvalue(String matrix, String zahl, String eigenwerte, String dimension)

===Parameter===
* '''matrix''' - Gibt an, ob die Matrix als Matrix über die ganzen Zahlen (ZZ), über die rationalen Zahlen (QQ) oder als Matrix über den reellen Zahlen (RR) aufgefasst werden soll.
* '''zahl''' - Gibt die Anzahl der Zeilen und Spalten der nxn-Matrix an: 1, 2, 3, ...
* '''eigenwerte''' - Gibt die Eigenwerte der Matrix an: [a,b,c,...].
* '''dimension''' - Gibt die Dimension der jeweiligen Eigenräume an [1,1,1,...]. Dabei ist der Index derselbe wie bei dem zugehörigen Eigenwert.

===Return Value===
* Gibt die Matrix als OpenMathOpject zurück.

===Beispiele===
randomMatrixEigenvalue('QQ','2','[1,2]','[1,1]')

randomMatrixEigenvalue('QQ','3','[2,3,4]','[1,1,1]')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() throws FunctionNotImplementedException, UndefinedFillInVariableException,
UndefinedExerciseVariableException, ParserException, ErroneousFillInVariableException,
ErroneousExerciseVariableException {
randomMatrixEigenvalueFillInVariableMap.put(1, ExpressionParser.parse("'[1,1,1]'", null, null));

randomMatrixEigenvalueExerciseVariableMap.put("a", ExpressionParser.parse("'[1,1,1]'", null, null));
}

@Test
public void testRandomMatrixEigenValue1() {
assertEquals(ExpressionParser.parse("matrix(matrixrow(1,0,0), matrixrow(0,1,0), matrixrow(0,0,1))", null, null),
Evaluator.evaluate("randomMatrixEigenvalue('QQ', '3', '[1,1,1]', '[1,1,1]')",
randomMatrixEigenvalueExerciseVariableMap, randomMatrixEigenvalueFillInVariableMap));
}

@Test
public void testRandomMatrixEigenValue2() {
assertEquals(ExpressionParser.parse("matrix(matrixrow(1,0), matrixrow(0,1))", null, null),
Evaluator.evaluate("randomMatrixEigenvalue('RR', '2', '[1,1]', '[1,1]')",
randomMatrixEigenvalueExerciseVariableMap, randomMatrixEigenvalueFillInVariableMap));
}

@Test
public void testRandomMatrixEigenValue3() {
assertEquals(ExpressionParser.parse("matrix(matrixrow(1))", null, null),
Evaluator.evaluate("randomMatrixEigenvalue('ZZ', '1', '[1]', '[1]')",
randomMatrixEigenvalueExerciseVariableMap, randomMatrixEigenvalueFillInVariableMap));
}

@Test
public void testRandomMatrixEigenValueWithInput() {
assertEquals(ExpressionParser.parse("matrix(matrixrow(1,0,0), matrixrow(0,1,0), matrixrow(0,0,1))", null, null),
Evaluator.evaluate("randomMatrixEigenvalue('QQ', '3', '[var=a]', '[var=a]')",
randomMatrixEigenvalueExerciseVariableMap, randomMatrixEigenvalueFillInVariableMap));
}

@Test
public void testRandomMatrixEigenValueWithVariables() {
assertEquals(ExpressionParser.parse("matrix(matrixrow(1,0,0), matrixrow(0,1,0), matrixrow(0,0,1))", null, null),
Evaluator.evaluate("randomMatrixEigenvalue('QQ', '3', '[pos=1]', '[pos=1]')",
randomMatrixEigenvalueExerciseVariableMap, randomMatrixEigenvalueFillInVariableMap));
}

@Test(expected = ParserException.class)
public void testRandomMatrixEigenValueWithONECharacter() {
Evaluator.evaluate("randomMatrixEigenvalue(ab, ab, ab, ab)", randomMatrixEigenvalueExerciseVariableMap,
randomMatrixEigenvalueFillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testRandomMatrixEigenValueWithEmptyStringArgument() {
Evaluator.evaluate("randomMatrixEigenvalue('', '', '', '')", randomMatrixEigenvalueExerciseVariableMap,
randomMatrixEigenvalueFillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testRandomMatrixEigenValueWithEmptyArgument() {
Evaluator.evaluate("randomMatrixEigenvalue()", randomMatrixEigenvalueExerciseVariableMap,
randomMatrixEigenvalueFillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testRandomMatrixEigenValueWithoutExerciseVariable() {
Evaluator.evaluate("randomMatrixEigenvalue('[var=j]', '[var=j]', '[var=j]', '[var=j]')",
randomMatrixEigenvalueExerciseVariableMap, randomMatrixEigenvalueFillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testRandomMatrixEigenValueWithoutInput() {
Evaluator.evaluate("randomMatrixEigenvalue('[pos=42]', '[pos=42]', '[pos=42]', '[pos=42]')",
randomMatrixEigenvalueExerciseVariableMap, randomMatrixEigenvalueFillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===
* Mit der Funktion [[evaluateInSage]] lassen sich die Eigenschaften der Matrix abfragen, z.B.
evaluateInSage('[var=Matrix].is_diagonalizable()') --> Gibt ''true'' zurück, wenn die Matrix diagonalisierbar ist

[[Kategorie:Evaluatorfunktion]]

Random

2017-09-19T06:38:37Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''random'' liefert eine Pseudozufallszahl in Form einer Gleitkommazahl im Bereich von 0 (inklusiv) bis 1 (exklusiv) zurück. Die Funktion benötigt keine Parameter.

=== Syntax ===
random()

===Parameter ===
* keine

=== Return Value ===
* Gibt eine Zufallszahl (double) zurück

=== Beispiele ===
====Standardfälle====
random() --> 0.451236789
random() --> 0.969492934

==== Benutzung mit Variablen ====
*keine

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@Test
public void testRandom() {

for(int i=0;i<10000;i++){
assertTrue(1 > Evaluator.getNumberResult("random()", exerciseVariableMap, fillInVariableMap));
assertTrue(0 <= Evaluator.getNumberResult("random()", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testRandomStatistically() {
HashMap<Double, Integer> statistics = new HashMap<>(); //<'Random Number', 'Occurrences'>
for (int i = 0; i < 10000; i++){
double random = Evaluator.getNumberResult("random()", exerciseVariableMap, fillInVariableMap);
if (statistics.containsKey(random)){
statistics.put(random, statistics.get(random) +1);
}else{
statistics.put(random, 1);
}
}

int max = 0;
for (int value : statistics.values() {
if(value > max){ max = value; }
}

assertTrue(2 >= max); //max 2 same random numbers out of 10 000
assertTrue(9990 < statistics.values().size()); //max 9 random numbers overlapping out of 10 000
}

@Test(expected=FunctionInvalidNumberOfArgumentsException.class)
public void testRandomWithOneArgument() {
Evaluator.getNumberResult("random(4)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidNumberOfArgumentsException.class)
public void testRandomWithTwoArguments() {
Evaluator.getNumberResult("random(4, 5)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidNumberOfArgumentsException.class)
public void testRandomWithThreeArguments() {
Evaluator.getNumberResult("random(2, 4, 0.1)", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===
* liefert niemals den Wert 1 zurück

[[Kategorie:Evaluatorfunktion]]

Pow

2017-09-19T06:37:55Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''pow'' repräsentiert eine Exponentialfunktion und errechnet die Potens der Basis mit dem Exponenten (<math>Basis^{Exponent}</math>). Die Funktion erwartet zwei Zahlen, einmal die Basis und einmal den Exponenten, und gibt die entsprechende Potens zurück.

=== Syntax ===
pow(float basis, float exponent)

=== Parameter ===
* '''basis''' - die Basis
* '''exponent''' - der Exponent

=== Return Value ===
*Gibt das Ergebnis von <math>Basis^{Exponent}</math> zurück

=== Beispiele ===
==== Standardfälle ====
pow(2,2) --> returns 4
pow(10,3) --> returns 1000

==== n-te Wurzel ziehen ====
pow(16,0.25) --> returns 2

==== Benutzung mit Variablen ====
pow([pos=1],[pos=3])
pow([var=a],[var=b])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
fillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>2</OMI></OMOBJ>"));
fillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMI>10</OMI></OMOBJ>"));

exerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>2</OMI></OMOBJ>"));
exerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMI>10</OMI></OMOBJ>"));
}

@Test
public void testPow1() {
assertEquals(4, Evaluator.getNumberResult("pow(2,2)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPow2() {
assertEquals(1000, Evaluator.getNumberResult("pow(10,3)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPow3() {
assertEquals(-8, Evaluator.getNumberResult("pow(-2,3)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPow4() {
assertEquals(1, Evaluator.getNumberResult("pow(10,0)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPow5() {
assertEquals(.1, Evaluator.getNumberResult("pow(10,-1)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPow6() {
assertEquals(1, Evaluator.getNumberResult("pow(1,-55)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPow7() {
assertEquals(0, Evaluator.getNumberResult("pow(0, 44)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithInput1() {
assertEquals(1024, Evaluator.getNumberResult("pow(2,[pos=2])", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithInput2() {
assertEquals(8, Evaluator.getNumberResult("pow([pos=1],3)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithVariables1() {
assertEquals(4, Evaluator.getNumberResult("pow(2,[var=a])", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithVariables2() {
assertEquals(1000, Evaluator.getNumberResult("pow([var=b],3)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithExpressions1() {
assertEquals(16, Evaluator.getNumberResult("pow(pow(-2,2), 2)", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testPowWithExpressions2() {
assertEquals(4096,
Evaluator.getNumberResult("pow(pow(-2,3), pow(2, 2))", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithExpressions3() {
assertEquals(16,
Evaluator.getNumberResult("pow(pow(-2,pow(2,1)), pow(2, 1))", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testPowWithPointNumbers() {
assertEquals(1, Evaluator.getNumberResult("pow(1.0, 1.3)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithInputCharacters() {
OMA oma = Evaluator.evaluate("pow(a, a)", exerciseVariableMap, fillInVariableMap).getOMA();
assertEquals("<OMA><OMS name=\"power\" cd=\"arith1\"/><OMV name=\"a\"/><OMV name=\"a\"/></OMA>", oma.toString());
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testPowWithOneArgument() {
Evaluator.getNumberResult("pow(4)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testPowWithThreeArguments() {
Evaluator.getNumberResult("pow(2, 2, 2)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testPowWithMissingExerciseVariable() {
Evaluator.getNumberResult("pow('[var=j]', '[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testPowWithMissingInput() {
Evaluator.getNumberResult("pow('[pos=42]', '[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===
* Wichtig: Dezimalzahlen müssen mit Punkt angegeben werden (z.B 3.4)

[[Kategorie:Evaluatorfunktion]]

Pow

2017-09-19T06:37:22Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''pow'' repräsentiert eine Exponentialfunktion und errechnet die Potens der Basis mit dem Exponenten (<math>Basis^{Exponent}</math>). Die Funktion erwartet zwei Zahlen, einmal die Basis und einmal den Exponenten, und gibt die entsprechende Potens zurück.

=== Syntax ===
pow(float basis, float exponent)

=== Parameter ===
* '''basis''' - die Basis
* '''exponent''' - der Exponent

=== Return Value ===
*Gibt das Ergebnis von <math>Basis^{Exponent}</math> zurück

=== Beispiele ===
==== Standardfälle ====
pow(2,2) --> returns 4
pow(10,3) --> returns 1000

==== n-te Wurzel ziehen ====
pow(16,0.25) --> returns 2

==== Benutzung mit Variablen ====
pow([pos=1],[pos=3])
pow([var=a],[var=b])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>2</OMI></OMOBJ>"));
fillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMI>10</OMI></OMOBJ>"));

exerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>2</OMI></OMOBJ>"));
exerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMI>10</OMI></OMOBJ>"));

}

@Test
public void testPow1() {
assertEquals(4, Evaluator.getNumberResult("pow(2,2)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPow2() {
assertEquals(1000, Evaluator.getNumberResult("pow(10,3)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPow3() {
assertEquals(-8, Evaluator.getNumberResult("pow(-2,3)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPow4() {
assertEquals(1, Evaluator.getNumberResult("pow(10,0)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPow5() {
assertEquals(.1, Evaluator.getNumberResult("pow(10,-1)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPow6() {
assertEquals(1, Evaluator.getNumberResult("pow(1,-55)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPow7() {
assertEquals(0, Evaluator.getNumberResult("pow(0, 44)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithInput1() {
assertEquals(1024, Evaluator.getNumberResult("pow(2,[pos=2])", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithInput2() {
assertEquals(8, Evaluator.getNumberResult("pow([pos=1],3)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithVariables1() {
assertEquals(4, Evaluator.getNumberResult("pow(2,[var=a])", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithVariables2() {
assertEquals(1000, Evaluator.getNumberResult("pow([var=b],3)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithExpressions1() {
assertEquals(16, Evaluator.getNumberResult("pow(pow(-2,2), 2)", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testPowWithExpressions2() {
assertEquals(4096,
Evaluator.getNumberResult("pow(pow(-2,3), pow(2, 2))", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithExpressions3() {
assertEquals(16,
Evaluator.getNumberResult("pow(pow(-2,pow(2,1)), pow(2, 1))", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testPowWithPointNumbers() {
assertEquals(1, Evaluator.getNumberResult("pow(1.0, 1.3)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testPowWithInputCharacters() {
OMA oma = Evaluator.evaluate("pow(a, a)", exerciseVariableMap, fillInVariableMap).getOMA();
assertEquals("<OMA><OMS name=\"power\" cd=\"arith1\"/><OMV name=\"a\"/><OMV name=\"a\"/></OMA>", oma.toString());
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testPowWithOneArgument() {
Evaluator.getNumberResult("pow(4)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testPowWithThreeArguments() {
Evaluator.getNumberResult("pow(2, 2, 2)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testPowWithMissingExerciseVariable() {
Evaluator.getNumberResult("pow('[var=j]', '[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testPowWithMissingInput() {
Evaluator.getNumberResult("pow('[pos=42]', '[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===
* Wichtig: Dezimalzahlen müssen mit Punkt angegeben werden (z.B 3.4)

[[Kategorie:Evaluatorfunktion]]

NumberOfVariables

2017-09-19T06:36:44Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktion ''numberOfVariables'' zählt die Variablen in einem Ausdruck. Sie erwartet einen String und gibt einen numerischen Ausdruck zurück.

===Syntax===
numberOfVariables(Expression term)

===Parameter===
* '''term''' - der Ausdruck dessen Variablen gezählt werden sollen

===Return Value===
* Gibt einen numerischen Ausdruck zurück.

===Beispiele===
numberOfVariables('2x+3a-2b') --> returns 3

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() throws FunctionNotImplementedException, UndefinedFillInVariableException,
UndefinedExerciseVariableException, ParserException, ErroneousFillInVariableException, ErroneousExerciseVariableException {
numberOfVariablesFillInVariableMap.put(1, ExpressionParser.parse("0", null, null));
numberOfVariablesFillInVariableMap.put(2, ExpressionParser.parse("3", null, null));
numberOfVariablesFillInVariableMap.put(3, ExpressionParser.parse("x", null, null));

numberOfVariablesExerciseVariableMap.put("a", ExpressionParser.parse("x", null, null));
numberOfVariablesExerciseVariableMap.put("b", ExpressionParser.parse("3", null, null));
}

@Test
public void testNumberOfVariables1() {
assertEquals(3, Evaluator.getNumberResult("numberOfVariables('2x+3a-x+2b')",
numberOfVariablesExerciseVariableMap, numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariables2() {
assertEquals(1, Evaluator.getNumberResult("numberOfVariables('2x+3x-x+2x')",
numberOfVariablesExerciseVariableMap, numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariables3() {
assertEquals(5, Evaluator.getNumberResult("numberOfVariables('sin(i)*E^(e)+ q/sqrt(s)')",
numberOfVariablesExerciseVariableMap, numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariables4() {
assertEquals(0, Evaluator.getNumberResult("numberOfVariables('5')", numberOfVariablesExerciseVariableMap,
numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariablesWithInput1() {
assertEquals(3, Evaluator.getNumberResult("numberOfVariables('2*x+3*a-x+2*b')",
numberOfVariablesExerciseVariableMap, numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariablesWithInput2() {
assertEquals(3, Evaluator.getNumberResult("numberOfVariables('2*[pos=3]+3*a-[pos=3]+2*b')",
numberOfVariablesExerciseVariableMap, numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariablesWithInput3() {
assertEquals(3, Evaluator.getNumberResult("numberOfVariables('2*[pos=3]+3*a-[pos=3]+2*b')",
numberOfVariablesExerciseVariableMap, numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariablesWithInput4() {
assertEquals(2, Evaluator.getNumberResult("numberOfVariables('2*[pos=3]+3*[pos=3]-[pos=3]+2*b')",
numberOfVariablesExerciseVariableMap, numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariablesWithVariables1() {
assertEquals(3, Evaluator.getNumberResult("numberOfVariables('2x+3a-x+2b')",
numberOfVariablesExerciseVariableMap, numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariablesWithVariables2() {
assertEquals(3, Evaluator.getNumberResult("numberOfVariables('2[var=a]+3a-[var=a]+2b')",
numberOfVariablesExerciseVariableMap, numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariablesWithVariables3() {
assertEquals(3, Evaluator.getNumberResult("numberOfVariables('2[var=a]+3a-[var=a]+2b')",
numberOfVariablesExerciseVariableMap, numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariablesWithVariables4() {
assertEquals(2, Evaluator.getNumberResult("numberOfVariables('2[var=a]+3[var=a]-[var=a]+2b')",
numberOfVariablesExerciseVariableMap, numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariablesWithONECharacter() {
assertEquals(1, Evaluator.getNumberResult("numberOfVariables(a)", numberOfVariablesExerciseVariableMap,
numberOfVariablesFillInVariableMap), 0.0);
}

@Test
public void testNumberOfVariablesWithEmptyStringArguments() {
Evaluator.getNumberResult("numberOfVariables('')", numberOfVariablesExerciseVariableMap,
numberOfVariablesFillInVariableMap);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testNumberOfVariablesWithEmptyArgument() {
Evaluator.getNumberResult("numberOfVariables()", numberOfVariablesExerciseVariableMap,
numberOfVariablesFillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testNumberOfVariablesWithMissingExerciseVariable() {
Evaluator.getNumberResult("numberOfVariables('[var=j]')", numberOfVariablesExerciseVariableMap,
numberOfVariablesFillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testNumberOfVariablesWithMissingInput() {
Evaluator.getNumberResult("numberOfVariables('[pos=42]')", numberOfVariablesExerciseVariableMap,
numberOfVariablesFillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===

[[Kategorie:Evaluatorfunktion]]

NotEqual

2017-09-19T06:36:23Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktionen ''notEqual'' vergleicht zwei Ausdrücke auf Gleichheit miteinander. Wenn die beiden Ausdrücke nicht übereinstimmen gibt die Funktion ''true'' zurück, ansonsten ''false''.

===Syntax===
a != b

===Parameter===
* '''a''' - double
* '''b''' - double

===Return Value===
* Gibt einen Boolean zurück.

===Beispiele===
<math>4!=6</math> --> returns ''true''

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() throws FunctionNotImplementedException, UndefinedFillInVariableException,
UndefinedExerciseVariableException, ParserException, ErroneousFillInVariableException, ErroneousExerciseVariableException {
notEqualFillInVariableMap.put(1, ExpressionParser.parse("3", null, null));
notEqualFillInVariableMap.put(2, ExpressionParser.parse("10", null, null));
notEqualFillInVariableMap.put(3, ExpressionParser.parse("3.5", null, null));

notEqualExerciseVariableMap.put("a", ExpressionParser.parse("3", null, null));
notEqualExerciseVariableMap.put("b", ExpressionParser.parse("10", null, null));
notEqualExerciseVariableMap.put("c", ExpressionParser.parse("3.5", null, null));
}

@Test
public void testNotEqual1() {
assertTrue(Evaluator.getBooleanResult("1 != 0", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqual2() {
assertTrue(Evaluator.getBooleanResult("30 != 7", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqual3() {
assertTrue(Evaluator.getBooleanResult("-10 != 3", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqual4() {
assertTrue(!Evaluator.getBooleanResult("1 != 1", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqual5() {
assertTrue(!Evaluator.getBooleanResult("0 != 0", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqual6() {
assertTrue(Evaluator.getBooleanResult("'a' != 'b'", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqual7() {
assertTrue(Evaluator.getBooleanResult("'' != 0", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqual8() {
assertTrue(Evaluator.getBooleanResult("0 != ''", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqual9() {
assertTrue(!Evaluator.getBooleanResult("0 != '0'", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithVariables1() {
assertTrue(Evaluator.getBooleanResult("[var=a] != 0", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithVariables2() {
assertTrue(Evaluator.getBooleanResult("30 != [var=a]", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithVariables3() {
assertTrue(Evaluator.getBooleanResult("[var=a]!= [var=b]", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithVariables4() {
assertTrue(!Evaluator.getBooleanResult("[var=a] != [var=a]", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithInput1() {
assertTrue(Evaluator.getBooleanResult("[pos=1] != 0", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithInput2() {
assertTrue(Evaluator.getBooleanResult("30 != [pos=1]", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithInput3() {
assertTrue(Evaluator.getBooleanResult("[pos=1] != [pos=2]", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithInput4() {
assertTrue(!Evaluator.getBooleanResult("[pos=1] != [pos=1]", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithEncapsulation1() {
assertFalse(Evaluator.getBooleanResult("1 != (1 != 0)", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithEncapsulation2() {
assertTrue(Evaluator.getBooleanResult("1 != (1 != (1 != 0))", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithEncapsulation3() {
assertTrue(Evaluator.getBooleanResult("1 != (1 != (1 != (1 != (1 != 0))))", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithEncapsulation4() {
assertFalse(Evaluator.getBooleanResult("1 != (1 != (1 != (1 != (1 != 1))))", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithEncapsulation5() {
assertTrue(Evaluator.getBooleanResult("((((1 != 0) != 1) != 1) != 1) != 1", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test
public void testNotEqualWithEncapsulation6() {
assertFalse(Evaluator.getBooleanResult("((((1 != 1) != 1) != 1) != 1) != 1", notEqualExerciseVariableMap, notEqualFillInVariableMap));
}

@Test(expected=ParserException.class)
public void testNotEqualWithWrongInputCharacter() {
Evaluator.getBooleanResult("1 == ab", notEqualExerciseVariableMap, notEqualFillInVariableMap);
fail();
}

@Test (expected=UndefinedExerciseVariableException.class)
public void testNotEqualWithMissingExcerciseVariable() {
Evaluator.getBooleanResult("[var=j] == 2", notEqualExerciseVariableMap, notEqualFillInVariableMap);
fail();
}

@Test (expected=UndefinedFillInVariableException.class)
public void testNotEqualWithMissingInput() {
Evaluator.getBooleanResult("[pos=42] == 2", notEqualExerciseVariableMap, notEqualFillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===

[[Kategorie:Evaluatorfunktion]]

Times

2017-09-19T06:35:39Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Bei der ''Multiplikation'' werden zwei Zahlen miteinander multipliziert.

===Syntax===
a * b

===Parameter===
* '''a''' - double
* '''b''' - double

===Return Value===
* Gibt eine expression zurück.

===Beispiele===
<math>3*5</math> --> returns 15

<math>1.4*2.3</math> --> returns 3.22

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
fillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));
fillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMI>10</OMI></OMOBJ>"));
fillInVariableMap.put(3, OMConverter.toObject("<OMOBJ><OMI>2.5</OMI></OMOBJ>"));
fillInVariableMap.put(4, OMConverter.toObject("<OMOBJ><OMI>4.3</OMI></OMOBJ>"));

exerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));
exerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMI>10</OMI></OMOBJ>"));
exerciseVariableMap.put("c", OMConverter.toObject("<OMOBJ><OMI>2.5</OMI></OMOBJ>"));
exerciseVariableMap.put("d", OMConverter.toObject("<OMOBJ><OMI>4.3</OMI></OMOBJ>"));
}

@Test
public void testMultiplication1() {
assertEquals(24, Evaluator.getNumberResult("6*4", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplication2() {
assertNotEquals(1, Evaluator.getNumberResult("7.3*2", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplication3() {
assertEquals(0, Evaluator.getNumberResult("7.3*0", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplication4() {
assertEquals(0, Evaluator.getNumberResult("0*0", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplication5() {
assertEquals(21.17, Evaluator.getNumberResult("7.3*2.9", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testMultiplicationWithNegativeNumber1() {
assertEquals(-29, Evaluator.getNumberResult("10*(-2.9)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplicationWithNegativeNumber2() {
assertNotEquals(1, Evaluator.getNumberResult("-7.3*2", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplicationWithVariables1() {
assertEquals(18, Evaluator.getNumberResult("6*[var=a]", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplicationWithVariables2() {
assertEquals(29, Evaluator.getNumberResult("[var=b]*2.9", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplicationWithVariables3() {
assertNotEquals(1, Evaluator.getNumberResult("7.3*[var=a]", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplicationWithVariables4() {
assertEquals(10.75, Evaluator.getNumberResult("[var=c]*[var=d]", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplicationWithInput1() {
assertEquals(18, Evaluator.getNumberResult("6*[pos=1]", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplicationWithInput2() {
assertEquals(29, Evaluator.getNumberResult("[pos=2]*2.9", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplicationWithInput3() {
assertNotEquals(1, Evaluator.getNumberResult("7.3*[pos=1]", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplicationWithInput4() {
assertEquals(10.75, Evaluator.getNumberResult("[pos=3]*[pos=4]", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplicationWithEncapsulation1() {
assertEquals(8, Evaluator.getNumberResult("2 * (2 * 2)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplicationWithEncapsulation2() {
assertEquals(16, Evaluator.getNumberResult("2 * (2 * (2 * 2))", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMultiplicationWithEncapsulation3() {
assertEquals(64,
Evaluator.getNumberResult("2 * (2 * (2 * (2 * (2 * 2))))", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMultiplicationWithEncapsulation4() {
assertEquals(64,
Evaluator.getNumberResult("((((2 * 2) * 2) * 2) * 2) * 2", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMultiplicationWithInputCharacter() {
OMA result = Evaluator.evaluate("6 * a", exerciseVariableMap, fillInVariableMap).getOMA();
assertEquals("<OMA><OMS name=\"times\" cd=\"arith1\"/><OMI>6</OMI><OMV name=\"a\"/></OMA>", result.toString());
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testMultiplicationWithWrongInputString() {
Evaluator.getNumberResult("6 * 'aabcd'", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testMultiplicationWithMissingExcerciseVariable() {
Evaluator.getNumberResult("[var=j] * 1", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testMultiplicationWithMissingInput() {
Evaluator.getNumberResult("[pos=42] * 1", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===
* Auch hier lässt sich das Ergebnis mit [[equal]] ("==") vergleichen.
* ACHTUNG: Besonders bei der Multiplikation von Dezimal-Zahlen tritt der folgende Rechner-Fehler auf: <math>7.3*2.9 = 21.16999999999998</math> anstatt <math>21.17</math>. Dies lässt sich auch hier verhindern wenn das Ergebnis auf zwei Nachkommastellen gerundet wird.

[[Kategorie:Evaluatorfunktion]]

Modulo

2017-09-19T06:35:02Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Der ''Modulo'' gibt den Rest bei einer Division zurück.

===Syntax===
a%b

===Parameter===
* '''a''' - double
* '''b''' - double

===Return Value===
* Gibt eine expression zurück.

===Beispiele===
<math>9%2</math> --> returns <math>1</math>

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
remainderFillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));
remainderFillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMI>10</OMI></OMOBJ>"));

remainderExerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));
remainderExerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMI>10</OMI></OMOBJ>"));
}

@Test
public void testModulus1() {
assertEquals(0, Evaluator.getNumberResult("5%5", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulus2() {
assertEquals(1, Evaluator.getNumberResult("1%3", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulus3() {
assertEquals(3, Evaluator.getNumberResult("7%4", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulus4() {
assertEquals(6, Evaluator.getNumberResult("6%7", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulus5() {
assertEquals(6, Evaluator.getNumberResult("6%7", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test(expected=FunctionInvalidArgumentTypeException.class) //Float Numbers so Error occurs
public void testModulus6() {
assertEquals(2, Evaluator.getNumberResult("12.0%2.5", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test (expected=FunctionInvalidArgumentException.class)
public void testModulus7() {
System.out.println(Evaluator.evaluate("4%0", exerciseVariableMap, fillInVariableMap).getOMI());
Evaluator.evaluate("4%0", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test
public void testModulusWithVariables1() {
assertEquals(0, Evaluator.getNumberResult("[var=a]%3", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithVariables2() {
assertEquals(1, Evaluator.getNumberResult("1%[var=a]", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithVariables3() {
assertEquals(3, Evaluator.getNumberResult("[var=a]%[var=b]", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithInput1() {
assertEquals(0, Evaluator.getNumberResult("[pos=1]%3", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithInput2() {
assertEquals(1, Evaluator.getNumberResult("1%[pos=1]", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithInput3() {
assertEquals(3, Evaluator.getNumberResult("[pos=1]%[pos=2]", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithNegativeNumbers1() {
assertEquals(-2, Evaluator.getNumberResult("-2 % 5", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test(expected=FunctionInvalidArgumentTypeException.class)// FloatNumber, so Error occurs
public void testModulusWithNegativeNumbers2() {
assertEquals(-2.3, Evaluator.getNumberResult("-2.3 % 5", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithNegativeNumbers3() {
assertEquals(-2, Evaluator.getNumberResult("-7 % -5", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithEncapsulation1() {
assertEquals(0, Evaluator.getNumberResult("1 % (1 % 2)", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithEncapsulation2() {
assertEquals(2, Evaluator.getNumberResult("2 % (3 % (4 % 5))", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithEncapsulation3() {
assertEquals(1, Evaluator.getNumberResult("1 % (5 % (7 % (9 % (5 % 10))))", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithEncapsulation4() {
assertNotEquals(3, Evaluator.getNumberResult("((3 % 4) % 4) % 3", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithEncapsulation5() {
assertEquals(0, Evaluator.getNumberResult("((((7 % 10) % 4) % 4) % 4) % 3", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test(expected=ParserException.class)
public void testModulusWithWrongInputCharacter() {
Evaluator.getNumberResult("6 % ab", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidArgumentTypeException.class)
public void testModulusWithWrongInputString() {
Evaluator.getNumberResult("6 % 'a'", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test (expected=UndefinedExerciseVariableException.class)
public void testModulusWithMissingExcerciseVariable() {
Evaluator.getNumberResult("[var=j] % 2", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test (expected=UndefinedFillInVariableException.class)
public void testModulusWithMissingInput() {
Evaluator.getNumberResult("[pos=42] % 2", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===
* Das Ergebnis kann mit [[equal]] ("==") abgefragt werden.

[[Kategorie:Evaluatorfunktion]]

Modulo

2017-09-19T06:34:47Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Der ''Modulo'' gibt den Rest bei einer Division zurück.

===Syntax===
a%b

===Parameter===
* '''a''' - double
* '''b''' - double

===Return Value===
* Gibt eine expression zurück.

===Beispiele===
<math>9%2</math> --> returns <math>1</math>

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

remainderFillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));
remainderFillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMI>10</OMI></OMOBJ>"));

remainderExerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>3</OMI></OMOBJ>"));
remainderExerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMI>10</OMI></OMOBJ>"));

}

@Test
public void testModulus1() {
assertEquals(0, Evaluator.getNumberResult("5%5", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulus2() {
assertEquals(1, Evaluator.getNumberResult("1%3", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulus3() {
assertEquals(3, Evaluator.getNumberResult("7%4", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulus4() {
assertEquals(6, Evaluator.getNumberResult("6%7", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulus5() {
assertEquals(6, Evaluator.getNumberResult("6%7", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test(expected=FunctionInvalidArgumentTypeException.class) //Float Numbers so Error occurs
public void testModulus6() {
assertEquals(2, Evaluator.getNumberResult("12.0%2.5", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test (expected=FunctionInvalidArgumentException.class)
public void testModulus7() {
System.out.println(Evaluator.evaluate("4%0", exerciseVariableMap, fillInVariableMap).getOMI());
Evaluator.evaluate("4%0", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test
public void testModulusWithVariables1() {
assertEquals(0, Evaluator.getNumberResult("[var=a]%3", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithVariables2() {
assertEquals(1, Evaluator.getNumberResult("1%[var=a]", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithVariables3() {
assertEquals(3, Evaluator.getNumberResult("[var=a]%[var=b]", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithInput1() {
assertEquals(0, Evaluator.getNumberResult("[pos=1]%3", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithInput2() {
assertEquals(1, Evaluator.getNumberResult("1%[pos=1]", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithInput3() {
assertEquals(3, Evaluator.getNumberResult("[pos=1]%[pos=2]", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithNegativeNumbers1() {
assertEquals(-2, Evaluator.getNumberResult("-2 % 5", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test(expected=FunctionInvalidArgumentTypeException.class)// FloatNumber, so Error occurs
public void testModulusWithNegativeNumbers2() {
assertEquals(-2.3, Evaluator.getNumberResult("-2.3 % 5", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithNegativeNumbers3() {
assertEquals(-2, Evaluator.getNumberResult("-7 % -5", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithEncapsulation1() {
assertEquals(0, Evaluator.getNumberResult("1 % (1 % 2)", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithEncapsulation2() {
assertEquals(2, Evaluator.getNumberResult("2 % (3 % (4 % 5))", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithEncapsulation3() {
assertEquals(1, Evaluator.getNumberResult("1 % (5 % (7 % (9 % (5 % 10))))", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithEncapsulation4() {
assertNotEquals(3, Evaluator.getNumberResult("((3 % 4) % 4) % 3", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test
public void testModulusWithEncapsulation5() {
assertEquals(0, Evaluator.getNumberResult("((((7 % 10) % 4) % 4) % 4) % 3", remainderExerciseVariableMap, remainderFillInVariableMap), 0.0);
}

@Test(expected=ParserException.class)
public void testModulusWithWrongInputCharacter() {
Evaluator.getNumberResult("6 % ab", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidArgumentTypeException.class)
public void testModulusWithWrongInputString() {
Evaluator.getNumberResult("6 % 'a'", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test (expected=UndefinedExerciseVariableException.class)
public void testModulusWithMissingExcerciseVariable() {
Evaluator.getNumberResult("[var=j] % 2", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test (expected=UndefinedFillInVariableException.class)
public void testModulusWithMissingInput() {
Evaluator.getNumberResult("[pos=42] % 2", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===
* Das Ergebnis kann mit [[equal]] ("==") abgefragt werden.

[[Kategorie:Evaluatorfunktion]]

Min

2017-09-19T06:34:25Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===

Die Funktion ''min'' ermittelt den kleinsten Wert zweier Zahlen. Die Funktion erwartet zwei zu vergleichende Zahlen und gibt die kleinere Zahl zurück.

=== Syntax ===
min(float zahl1, float zahl2)

=== Parameter ===
* '''zahl1''' - der erste zu vergleichende Wert
* '''zahl2''' - der zweite zu vergleichende Wert

=== Return Value ===
*Gibt die kleinere Zahl zurück

=== Beispiele ===
==== Standardfälle ====
min(12,3) --> returns 3
min(9.568,100) --> returns 9.568

==== Benutzung mit Variablen ====
min([pos=1],[pos=3])
min([var=a],[var=b])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>1</OMI></OMOBJ>"));
fillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMI>2</OMI></OMOBJ>"));
fillInVariableMap.put(3, OMConverter.toObject("<OMOBJ><OMI>-1</OMI></OMOBJ>"));

exerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>1</OMI></OMOBJ>"));
exerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMI>2</OMI></OMOBJ>"));
exerciseVariableMap.put("c", OMConverter.toObject("<OMOBJ><OMI>-1</OMI></OMOBJ>"));

}

@Test
public void testMin1() {
assertEquals(1, Evaluator.getNumberResult("min(1, 2)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMin2() {
assertEquals(2, Evaluator.getNumberResult("min(3, 2)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMin3() {
assertEquals(1, Evaluator.getNumberResult("min(1, 1)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMin4() {
assertEquals(0, Evaluator.getNumberResult("min(0, 0)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMin5() {
assertEquals(-2, Evaluator.getNumberResult("min(-2, 0)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMin6() {
assertEquals(-2, Evaluator.getNumberResult("min(-2, 2)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMinWithVariables1() {
assertEquals(1, Evaluator.getNumberResult("min([var=a], [var=b])", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMinWithVariables2() {
assertEquals(-1, Evaluator.getNumberResult("min([var=a], [var=c])", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMinWithInput1() {
assertEquals(1, Evaluator.getNumberResult("min([pos=1], [pos=2])", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMinWithInput2() {
assertEquals(-1, Evaluator.getNumberResult("min([pos=1], [pos=3])", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMinWithExpressions1() {
assertEquals(-12, Evaluator.getNumberResult("min(min(-12,2), 4)", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMinWithExpressions2() {
assertEquals(-12,
Evaluator.getNumberResult("min(min(-12,2), min(5, 8))", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMinWithExpressions3() {
assertEquals(-13, Evaluator.getNumberResult("min(min(-12,min(13,-13)), min(5, 8))", exerciseVariableMap,
fillInVariableMap), 0.0);
}

@Test
public void testMinWithPointNumbers1() {
assertEquals(1.0, Evaluator.getNumberResult("min(1.0, 1.3)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testMinWithWrongInputCharacter() {
Evaluator.getNumberResult("min(a, a)", exerciseVariableMap, fillInVariableMap);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testMinWithOneArgument() {
Evaluator.getNumberResult("min(2)", exerciseVariableMap, fillInVariableMap);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testMinWithThreeArguments() {
Evaluator.getNumberResult("min(1, 23, 4)", exerciseVariableMap, fillInVariableMap);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testMinWithMissingExerciseVariable() {
Evaluator.getNumberResult("min('[var=j]', '[var=j]')", exerciseVariableMap, fillInVariableMap);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testMinWithMissingInput() {
Evaluator.getNumberResult("min('[pos=42]', '[pos=42]')", exerciseVariableMap, fillInVariableMap);
}
</syntaxhighlight>

=== Hinweise ===
* Eine Gleitkommazahl wird mit einem Punkt anstatt eines Komma gebildet

[[Kategorie:Evaluatorfunktion]]

Max

2017-09-19T06:33:26Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===

Die Funktion ''max'' ermittelt den größten Wert zweier Zahlen. Die Funktion erwartet zwei zu vergleichende Zahlen und gibt die größte Zahl zurück.

=== Syntax ===
max(float zahl1, float zahl2)

=== Parameter ===
* '''zahl1''' - der erste zu vergleichende Wert
* '''zahl2''' - der zweite zu vergleichende Wert

=== Return Value ===
*Gibt die größte Zahl zurück

=== Beispiele ===
==== Standardfälle ====
max(12,3) --> returns 12
max(9.568,100) --> returns 100

==== Benutzung mit Variablen ====
max([pos=1],[pos=3])
max([var=a],[var=b])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
fillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>1</OMI></OMOBJ>"));
fillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMI>2</OMI></OMOBJ>"));
fillInVariableMap.put(3, OMConverter.toObject("<OMOBJ><OMI>-1</OMI></OMOBJ>"));

exerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>1</OMI></OMOBJ>"));
exerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMI>2</OMI></OMOBJ>"));
exerciseVariableMap.put("c", OMConverter.toObject("<OMOBJ><OMI>-1</OMI></OMOBJ>"));
}

@Test
public void testMax1() {
assertEquals(2, Evaluator.getNumberResult("max(1, 2)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMax2() {
assertEquals(3, Evaluator.getNumberResult("max(3, 2)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMax3() {
assertEquals(1, Evaluator.getNumberResult("max(1, 1)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMax4() {
assertEquals(0, Evaluator.getNumberResult("max(0, 0)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMax5() {
assertEquals(0, Evaluator.getNumberResult("max(-2, 0)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMax6() {
assertEquals(2, Evaluator.getNumberResult("max(-2, 2)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testMaxWithVariables1() {
assertEquals(2, Evaluator.getNumberResult("max([var=a], [var=b])", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMaxWithVariables2() {
assertEquals(1, Evaluator.getNumberResult("max([var=a], [var=c])", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMaxWithInput1() {
assertEquals(2, Evaluator.getNumberResult("max([pos=1], [pos=2])", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMaxWithInput2() {
assertEquals(1, Evaluator.getNumberResult("max([pos=1], [pos=3])", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMaxWithExpressions1() {
assertEquals(12, Evaluator.getNumberResult("max(max(12,2), 4)", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMaxWithExpressions2() {
assertEquals(12, Evaluator.getNumberResult("max(max(12,2), max(5, 8))", exerciseVariableMap, fillInVariableMap),
0.0);
}

@Test
public void testMaxWithExpressions3() {
assertEquals(13, Evaluator.getNumberResult("max(max(12,max(13,-13)), max(5, 8))", exerciseVariableMap,
fillInVariableMap), 0.0);
}

@Test
public void testMaxWithPointNumbers1() {
assertEquals(1.3, Evaluator.getNumberResult("max(1.0, 1.3)", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testMaxWithWrongInputCharacter() {
Evaluator.getNumberResult("max(a, a)", exerciseVariableMap, fillInVariableMap);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testMaxWithOneArgument() {
Evaluator.getNumberResult("max(2)", exerciseVariableMap, fillInVariableMap);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testMaxWithThreeArguments() {
Evaluator.getNumberResult("max(1, 23, 4)", exerciseVariableMap, fillInVariableMap);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testMaxWithMissingExerciseVariable() {
Evaluator.getNumberResult("max('[var=j]', '[var=j]')", exerciseVariableMap, fillInVariableMap);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testMaxWithMissingInput() {
Evaluator.getNumberResult("max('[pos=42]', '[pos=42]')", exerciseVariableMap, fillInVariableMap);
}
</syntaxhighlight>

=== Hinweise ===
* Eine Gleitkommazahl wird mit einem Punkt anstatt eines Komma gebildet

[[Kategorie:Evaluatorfunktion]]

Matches

2017-09-19T06:32:57Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''matches'' prüft, ob ein String einem gegebenen regulären Ausdruck genügt. Die Funktion erwartet zwei String, die Zeichenkette, die geprüft werden soll, und den regulärer Ausdruck, der als Grundlage zum Prüfen gilt. Es wird ein Boolean zurückgegeben.

=== Syntax ===
matches(String zeichenkette, String regExp)

=== Parameter ===
* '''zeichenkette''' - zu prüfende Zeichenkette
* '''regExp''' - regulärer Ausdruck

=== Return Value ===
* Gibt einen Boolean zurück

=== Beispiele ===
==== Standardfälle ====
matches('Abcd0','[A-Za-z0-9]*') --> returns true

==== Benutzung von Variablen ====
matches('abababa','[var=a]')
matches('[var=c]','\\d')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
fillInVariableMap.put(7, OMConverter.toObject("<OMOBJ><OMSTR>abababa</OMSTR></OMOBJ>"));
fillInVariableMap.put(8, OMConverter.toObject("<OMOBJ><OMI>6</OMI></OMOBJ>"));
fillInVariableMap.put(9, OMConverter.toObject("<OMOBJ><OMI>2</OMI></OMOBJ>"));

exerciseVariableMap.put("g", OMConverter.toObject("<OMOBJ><OMSTR>abababa</OMSTR></OMOBJ>"));
exerciseVariableMap.put("h", OMConverter.toObject("<OMOBJ><OMI>6</OMI></OMOBJ>"));
exerciseVariableMap.put("i", OMConverter.toObject("<OMOBJ><OMI>2</OMI></OMOBJ>"));
}

@Test
public void testMatches1() {
assertTrue(Evaluator.getBooleanResult("matches('abababa','abababa')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testMatches2() {
assertTrue(Evaluator.getBooleanResult("matches('abcdefghijklmnopqrstuvwxyz','abcdefghijklmnopqrstuvwxyz')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testMatches3() {
assertTrue(Evaluator.getBooleanResult("matches('5', '[0-6]+')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testMatches4() {
assertTrue(Evaluator.getBooleanResult("matches('Ab3', '[A-Za-z0-9]+')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testMatches5() {
assertTrue(Evaluator.getBooleanResult("matches('2', '\\d')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testMatches6() {
assertTrue(!Evaluator.getBooleanResult("matches('abc', '\\d')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testMatchesAndInput1() {
assertTrue(Evaluator.getBooleanResult("matches('abababa','[pos=7]')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testMatchesAndInput2() {
assertTrue(Evaluator.getBooleanResult("matches('5','[0-[pos=8]]+')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testMatchesAndInput3() {
assertTrue(Evaluator.getBooleanResult("matches('[pos=9]', '\\d')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testMatchesWithVariables1() {
assertTrue(Evaluator.getBooleanResult("matches('abababa','[var=g]')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testMatchesWithVariables2() {
assertTrue(Evaluator.getBooleanResult("matches('5', '[0-[var=h]]+')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testMatchesWithVariables3() {
assertTrue(Evaluator.getBooleanResult("matches('[var=i]', '\\d')", exerciseVariableMap, fillInVariableMap));
}

@Test(expected=ParserException.class)
public void testMatchesWithWrongInputCharacter() {
Evaluator.getNumberResult("matches(ab, ab)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidNumberOfArgumentsException.class)
public void testMatchesWithOneArgument() {
Evaluator.getNumberResult("matches('abc')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidNumberOfArgumentsException.class)
public void testmatchesWithThreeArguments() {
Evaluator.getNumberResult("matches('str', '[i]+', 'string')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=UndefinedExerciseVariableException.class)
public void testMatchesWithMissingExerciseVariable() {
Evaluator.getNumberResult("matches('[var=j]', '[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=UndefinedFillInVariableException.class)
public void testMatchesWithMissingInput() {
Evaluator.getNumberResult("matches('[pos=42]', '[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

Log

2017-09-19T06:31:34Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''log'' beschreibt die natürliche Logarithmusfunktion zur Basis <math>e</math>. Die Funktion erwartet eine rationale Zahl und gibt eine rationale Zahl zurück.

=== Syntax ===
log(double zahl)

=== Parameter ===
* '''zahl''' - rationale Zahl, auf die die Logarithmusfunktion angewendet wird

=== Return Value ===
* Gibt eine rationale Zahl zurück

=== Beispiele ===
==== Standardfälle ====
log(100) --> returns 4.605170185988092
log(1) --> returns 0

==== Benutzung von Variablen ====
log([pos=1])
log([var=a])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>5</OMI></OMOBJ>"));
fillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMF dec=\"13.7465\"/></OMOBJ>"));

exerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>5</OMI></OMOBJ>"));
exerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMF dec=\"13.7465\"/></OMOBJ>"));

}

@Test
public void testLog1() {
assertEquals(Math.log(100), Evaluator.getNumberResult("log(100)", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLog2() {
assertEquals(Math.log(197), Evaluator.getNumberResult("log(197)", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLog3() {
assertEquals(Math.log(100), Evaluator.getNumberResult("log('100')", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLog4() {
assertEquals(Math.log(197), Evaluator.getNumberResult("log('197')", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLogWithInput1() {
assertEquals(Math.log(5), Evaluator.getNumberResult("log([pos=1])", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLogWithInput2() {
assertEquals(Math.log(13.7465),
Evaluator.getNumberResult("log([pos=2])", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testLogWithVariables1() {
assertEquals(Math.log(5), Evaluator.getNumberResult("log([var=a])", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLogWithVariables2() {
assertEquals(Math.log(13.7465),
Evaluator.getNumberResult("log([var=b])", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testLogWithExpressions1() {
assertEquals(Math.log(Math.log(12)),
Evaluator.getNumberResult("log(log(12))", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testLogWithExpressions2() {
assertEquals(Math.log(Math.log(Math.log(12))),
Evaluator.getNumberResult("log(log(log(12)))", exerciseVariableMap, fillInVariableMap), 0.0001);
}

@Test
public void testLogWithPointNumbers1() {
assertEquals(Math.log(1.0), Evaluator.getNumberResult("log(1.0)", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLogWithPointNumbers2() {
assertEquals(Math.log(.1), Evaluator.getNumberResult("log(0.1)", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test
public void testLogWithPointNumbers3() {
assertEquals(Math.log(.1234), Evaluator.getNumberResult("log(0.1234)", exerciseVariableMap, fillInVariableMap),
0.0001);
}

@Test(expected = FunctionInvalidArgumentException.class) // NaN
public void testLogAtDefinition1() {
Evaluator.getNumberResult("log(-1)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentException.class) // NaN
public void testLogAtDefinition2() {
Evaluator.getNumberResult("log(-0.1)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentException.class) // NaN
public void testLogAtDefinition3() {
Evaluator.getNumberResult("log(0)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testLogWithWrongInputCharacter() {
Evaluator.getNumberResult("log(a)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testLogWithTwoArguments() {
Evaluator.getNumberResult("log(2, 1)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testLogWithThreeArguments() {
Evaluator.getNumberResult("log(1, 23, 4)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testLogWithMissingExerciseVariable() {
Evaluator.getNumberResult("log('[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testLogWithMissingInput() {
Evaluator.getNumberResult("log('[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===
* Aufgrund von der Rechengenauigkeit des Computers, wird in jedem Fall eine rationale Zahl zurückgegeben. Sollte der tatsächliche Funktionswert irrational sein, wird entsprechend gerundet.

[[Kategorie:Evaluatorfunktion]]

LessThanOrEqual

2017-09-19T06:31:11Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktion ''lessThanOrEqual'' vergleicht zwei Ausdrücke der Größe nach miteinander und gibt einen Wahrheitswert zurück, abhängig davon, ob der linksstehende Ausdruck kleiner-gleich dem rechtsstehenden Ausdruck ist.

===Syntax===
a <= b

===Parameter===
* '''a''' - double
* '''b''' - double

===Return Value===
* Gibt einen Boolean zurück.
*: Wenn der linke Ausdruck kleiner-gleich dem rechten Ausdruck ist, wird <code>true</code> zurückgegeben, andernfalls <code>false</code>.

===Beispiele===
<math>2 <= 4</math> --> returns ''true''

<math>4 <= 4</math> --> returns ''true''

<math>3 <= 2</math> --> returns ''false''

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() throws FunctionNotImplementedException, UndefinedFillInVariableException,
UndefinedExerciseVariableException, ParserException, ErroneousFillInVariableException, ErroneousExerciseVariableException {
lessThanOrEqualFillInVariableMap.put(1, ExpressionParser.parse("3", null, null));
lessThanOrEqualFillInVariableMap.put(2, ExpressionParser.parse("1", null, null));
lessThanOrEqualFillInVariableMap.put(3, ExpressionParser.parse("2.5", null, null));

lessThanOrEqualExerciseVariableMap.put("a", ExpressionParser.parse("8", null, null));
lessThanOrEqualExerciseVariableMap.put("b", ExpressionParser.parse("25", null, null));
lessThanOrEqualExerciseVariableMap.put("c", ExpressionParser.parse("2.5", null, null));
}

@Test
public void testLessThanOrEqual1() {
assertTrue(!Evaluator.getBooleanResult("22<=8", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqual2() {
assertTrue(Evaluator.getBooleanResult("8<=8", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqual3() {
assertTrue(Evaluator.getBooleanResult("2<=8", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqual4() {
assertTrue(Evaluator.getBooleanResult("8<=9", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqual5() {
assertTrue(!Evaluator.getBooleanResult("45<=7", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqual6() {
assertTrue(Evaluator.getBooleanResult("7<=7", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqual7() {
assertTrue(Evaluator.getBooleanResult("-0.2<=0", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqual8() {
assertTrue(Evaluator.getBooleanResult("0<=0", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithVariables1() {
assertTrue(!Evaluator.getBooleanResult("22<=[var=a]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithVariables2() {
assertTrue(Evaluator.getBooleanResult("3<=[var=a]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithVariables3() {
assertTrue(Evaluator.getBooleanResult("2<=[var=a]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithVariables4() {
assertTrue(Evaluator.getBooleanResult("8<=[var=b]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithVariables5() {
assertTrue(Evaluator.getBooleanResult("8<=[var=a]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithVariables6() {
assertTrue(!Evaluator.getBooleanResult("[var=b]<=23", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithVariables7() {
assertTrue(Evaluator.getBooleanResult("[var=a]<=[var=a]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithVariables8() {
assertTrue(Evaluator.getBooleanResult("[var=a]<=[var=b]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithVariables9() {
assertTrue(!Evaluator.getBooleanResult("[var=b]<=[var=a]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithInput1() {
assertTrue(!Evaluator.getBooleanResult("22<=[pos=1]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithInput2() {
assertTrue(Evaluator.getBooleanResult("3<=[pos=1]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithInput3() {
assertTrue(Evaluator.getBooleanResult("2<=[pos=1]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithInput4() {
assertTrue(Evaluator.getBooleanResult("3<=[pos=1]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithInput5() {
assertTrue(Evaluator.getBooleanResult("[pos=2]<=5", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithInput6() {
assertTrue(!Evaluator.getBooleanResult("5<=[pos=2]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithInput7() {
assertTrue(!Evaluator.getBooleanResult("[pos=1]<=[pos=2]", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithEncapsulation1() {
assertTrue(Evaluator.getBooleanResult("1 <= (1 <= 2)", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithEncapsulation2() {
assertTrue(Evaluator.getBooleanResult("1 <= (1 <= (0 <= 1))", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithEncapsulation3() {
assertTrue(Evaluator.getBooleanResult("0 <= (0 <= (0 <= (0 <= (0 <= 1))))", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test
public void testLessThanOrEqualWithEncapsulation4() {
assertTrue(Evaluator.getBooleanResult("((((1 <= 1) <= 1) <= 1) <= 1) <= 1", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap));
}

@Test(expected=ParserException.class)
public void testLessThanOrEqualWithWrongInputCharacter() {
Evaluator.getBooleanResult("6 <= ab", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidArgumentTypeException.class)
public void testLessThanOrEqualWithWrongInputString() {
Evaluator.getBooleanResult("6 <= 'a'", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap);
fail();
}

@Test (expected=UndefinedExerciseVariableException.class)
public void testLessThanOrEqualWithMissingExcerciseVariable() {
Evaluator.getBooleanResult("[var=j] <= 2", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap);
fail();
}

@Test (expected=UndefinedFillInVariableException.class)
public void testLessThanOrEqualWithMissingInput() {
Evaluator.getBooleanResult("[pos=42] <= 2", lessThanOrEqualExerciseVariableMap, lessThanOrEqualFillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===

[[Kategorie:Evaluatorfunktion]]

LessThan

2017-09-19T06:30:40Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktion ''lessThan'' vergleicht zwei Ausdrücke nach der Größe miteinander.

===Syntax===
a 3 < 5</math>

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() throws FunctionNotImplementedException, UndefinedFillInVariableException,
UndefinedExerciseVariableException, ParserException, ErroneousFillInVariableException, ErroneousExerciseVariableException {
lessThanFillInVariableMap.put(1, ExpressionParser.parse("3", null, null));
lessThanFillInVariableMap.put(2, ExpressionParser.parse("1", null, null));

lessThanExerciseVariableMap.put("a", ExpressionParser.parse("8", null, null));
lessThanExerciseVariableMap.put("b", ExpressionParser.parse("25", null, null));
}

@Test
public void testLessThan1() {
assertTrue(Evaluator.getBooleanResult("8<22", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThan2() {
assertTrue(!Evaluator.getBooleanResult("22<8", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThan3() {
assertTrue(Evaluator.getBooleanResult("3.5<5.7", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThan4() {
assertTrue(Evaluator.getBooleanResult("-1<1", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThan5() {
assertTrue(Evaluator.getBooleanResult("-0.2<0", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithExerciseVariables1() {
assertTrue(Evaluator.getBooleanResult("8<[var=b]", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithExerciseVariables2() {
assertTrue(!Evaluator.getBooleanResult("9<[var=a]", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithExerciseVariables3() {
assertTrue(!Evaluator.getBooleanResult("22<[var=a]", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithExerciseVariables4() {
assertTrue(Evaluator.getBooleanResult("[var=a]<100", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithExerciseVariables5() {
assertTrue(Evaluator.getBooleanResult("2<[var=a]", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithExerciseVariables6() {
assertTrue(
Evaluator.getBooleanResult("[var=a]<[var=b]", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithExerciseVariables7() {
assertTrue(
!Evaluator.getBooleanResult("[var=b]<[var=a]", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithInput1() {
assertTrue(Evaluator.getBooleanResult("2<[pos=1]", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithInput2() {
assertTrue(Evaluator.getBooleanResult("[pos=2]<34", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithInput3() {
assertTrue(!Evaluator.getBooleanResult("2<[pos=2]", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithInput4() {
assertTrue(!Evaluator.getBooleanResult("22<[pos=1]", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithInput5() {
assertTrue(Evaluator.getBooleanResult("2<[pos=1]", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithInput6() {
assertTrue(
Evaluator.getBooleanResult("[pos=2]<[pos=1]", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithInput7() {
assertTrue(
!Evaluator.getBooleanResult("[pos=1]<[pos=2]", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithEncapsulation1() {
assertTrue(!Evaluator.getBooleanResult("1 < (1 < 2)", lessThanExerciseVariableMap, lessThanFillInVariableMap));
}

@Test
public void testLessThanWithEncapsulation2() {
assertTrue(Evaluator.getBooleanResult("0 < (0 < (0 < 1))", lessThanExerciseVariableMap,
lessThanFillInVariableMap));
}

@Test
public void testLessThanWithEncapsulation3() {
assertTrue(Evaluator.getBooleanResult("0 < (0 < (0 < (0 < (0 < 1))))", lessThanExerciseVariableMap,
lessThanFillInVariableMap));
}

@Test
public void testLessThanWithEncapsulation4() {
assertTrue(!Evaluator.getBooleanResult("((((1 < 1) < 1) < 1) < 1) < 1", lessThanExerciseVariableMap,
lessThanFillInVariableMap));
}

@Test(expected = ParserException.class)
public void testLessThanWithWrongInputCharacter() {
Evaluator.getBooleanResult("6 < ab", lessThanExerciseVariableMap, lessThanFillInVariableMap);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testLessThanWithWrongInputString() {
Evaluator.getBooleanResult("6 < 'a'", lessThanExerciseVariableMap, lessThanFillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testLessThanWithMissingExcerciseVariable() {
Evaluator.getBooleanResult("[var=j] < 2", lessThanExerciseVariableMap, lessThanFillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testLessThanWithMissingInput() {
Evaluator.getBooleanResult("[pos=42] < 2", lessThanExerciseVariableMap, lessThanFillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===

[[Kategorie:Evaluatorfunktion]]

Length

2017-09-19T06:30:11Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''length'' gibt die Länge einer gegebenen Zeichenkette zurück. Die Funktion erwartet einen String und gibt eine Ganzzahl zurück.

=== Syntax ===
length(String zeichenkette)

=== Parameter ===
* '''zeichenkette''' - Zeichenkette deren Länge bestimmt werden soll

=== Return Value ===
* Gibt eine Ganzzahl zurück

=== Beispiele ===
==== Standardfälle ====
length('Hello World!') --> returns 12
length('a') --> returns 1

==== Benutzung von Variablen ====
length('[pos=1]')
length('[var=a]')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(7, OMConverter.toObject("<OMOBJ><OMSTR>Haveaniceday</OMSTR></OMOBJ>"));
fillInVariableMap.put(8, OMConverter.toObject("<OMOBJ><OMSTR>stillworking</OMSTR></OMOBJ>"));

exerciseVariableMap.put("g", OMConverter.toObject("<OMOBJ><OMSTR>Haveaniceday</OMSTR></OMOBJ>"));
exerciseVariableMap.put("h", OMConverter.toObject("<OMOBJ><OMSTR>stillworking</OMSTR></OMOBJ>"));

}

@Test
public void testLength1() {
assertEquals(5, Evaluator.getNumberResult("length('abcde')", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testLength2() {
assertEquals(14, Evaluator.getNumberResult("length('another string')", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testLength3() {
assertEquals(0, Evaluator.getNumberResult("length('')", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testLength4() {
assertEquals(2, Evaluator.getNumberResult("length(' ')", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testLengthWithInput1() {
assertEquals(12, Evaluator.getNumberResult("length('[pos=7]')", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testLengthWithInput2() {
assertEquals(12, Evaluator.getNumberResult("length('[pos=8]')", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testLengthWithVariables1() {
assertEquals(12, Evaluator.getNumberResult("length('[var=g]')", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test
public void testLengthWithVariables2() {
assertEquals(12, Evaluator.getNumberResult("length('[var=h]')", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test(expected=ParserException.class)
public void testLengthWithWrongInputCharacter() {
Evaluator.getNumberResult("length(ab)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidNumberOfArgumentsException.class)
public void testLengthWithTwoArguments() {
Evaluator.getNumberResult("length('abab', 'abab')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidNumberOfArgumentsException.class)
public void testLengthWithThreeArguments() {
Evaluator.getNumberResult("length('abab', 'ab', 'ab')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=UndefinedExerciseVariableException.class)
public void testLengthWithMissingExerciseVariable() {
Evaluator.getNumberResult("length('[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=UndefinedFillInVariableException.class)
public void testLengthWithMissingInput() {
Evaluator.getNumberResult("length('[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

LastIndexOf

2017-09-19T06:29:52Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''lastIndexOf'' bestimmt die Position an der eine Zeichenkette oder ein einzelnes Zeichen das letzte Mal innerhalb einer anderen Zeichenkette vorkommt. Außerdem muss angegeben werden, ab welcher Stelle innerhalb der durchsuchten Zeichenkette gesucht werden soll. Die Funktion erwartet zwei Strings, die zu durchsuchende und die zu suchende Zeichenkette, und eine Ganzzahl, bis zu welcher Stelle die Suche durchgeführt werden soll. Es wird eine Ganzzahl zurückgegeben.

=== Syntax ===
lastIndexOf(String zeichenkette, String muster, int position)

=== Parameter ===
* '''zeichenkette''' - Zeichenkette in dem gesucht wird
* '''muster''' - Zeichenkette, die innnerhalb der ersten gesucht wird
* '''position''' - Endpositition der Suche

=== Return Value ===
* Gibt eine Ganzzahl zurück

=== Beispiele ===
==== Standardfälle ====
lastIndexOf('Hello World!','o',0) --> returns -1
lastIndexOf('Hello World!','o',6) --> returns 4

==== Benutzung von Variablen ====
lastIndexOf('[pos=1]','x',10)
lastIndexOf('text','[var=a]',4)
lastIndexOf('[var=b]','x',[pos=2])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(7, OMConverter.toObject("<OMOBJ><OMSTR>oneString</OMSTR></OMOBJ>"));
fillInVariableMap.put(8, OMConverter.toObject("<OMOBJ><OMSTR>b</OMSTR></OMOBJ>"));

exerciseVariableMap.put("g", OMConverter.toObject("<OMOBJ><OMSTR>oneString</OMSTR></OMOBJ>"));
exerciseVariableMap.put("h", OMConverter.toObject("<OMOBJ><OMSTR>b</OMSTR></OMOBJ>"));

}

@Test
public void testLastIndexOf1() {
assertEquals(4, Evaluator.getNumberResult("lastIndexOf('abbbb','b',5)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testLastIndexOf2() {
assertEquals(0, Evaluator.getNumberResult("lastIndexOf('cabade','c',10)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testLastIndexOf3() {
assertEquals(-1, Evaluator.getNumberResult("lastIndexOf('cabade','test',10)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testLastIndexOf4() {
assertEquals(6, Evaluator.getNumberResult("lastIndexOf('he llo','lo',7)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testLastIndexOf5() {
assertEquals(0, Evaluator.getNumberResult("lastIndexOf('','',0)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testLastIndexOfWithInput1() {
assertEquals(3, Evaluator.getNumberResult("lastIndexOf('[pos=7]','S',7)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testLastIndexOfWithInput2() {
assertEquals(4, Evaluator.getNumberResult("lastIndexOf('abbbb','[pos=8]',5)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testLastIndexOfWithVariable1() {
assertEquals(3, Evaluator.getNumberResult("lastIndexOf('[var=g]','S',7)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testLastIndexOfWithVariable2() {
assertEquals(4, Evaluator.getNumberResult("lastIndexOf('abbbb','[var=h]',5)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test(expected=ParserException.class)
public void testLastIndexOfWithWrongInputCharacter() {
Evaluator.getNumberResult("lastIndexOf(ab, ab, ab)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidNumberOfArgumentsException.class)
public void testLastIndexOfWithOneArgument() {
Evaluator.getNumberResult("lastIndexOf('abab')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test
public void testLastIndexOfWithTwoArguments() {
assertEquals(2, Evaluator.getNumberResult("lastIndexOf('abab', 'ab')", exerciseVariableMap, fillInVariableMap), 0.0);
}

@Test(expected=UndefinedExerciseVariableException.class)
public void testLastIndexOfWithMissingExerciseVariable() {
Evaluator.getNumberResult("lastIndexOf('[var=j]', '[var=j]', '[var=j]')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=UndefinedFillInVariableException.class)
public void testLastIndexOfWithMissingInput() {
Evaluator.getNumberResult("lastIndexOf('[pos=42]', '[pos=42]', '[pos=42]')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===
* Die Nummerierung innerhalb der Zeichenkette beginnt mit 0.
* Sollte die gesuchte Zeichenkette nicht gefunden werden, gibt die Funktion -1 zurück.

[[Kategorie:Evaluatorfunktion]]

IsPolynomial

2017-09-18T11:04:24Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktion ''isPolynomial'' prüft, ob ein Ausdruck ein Polynom ist. Es können nur Polynome in einer Variable überprüft werden. Die Funktion benötigt zwei Strings, den zu überprüfenden Ausdruck und die Variable in welcher der Ausdruck ein Polynom sein soll. Sie gibt einen Boolean zurück.

===Syntax===
isPolynomial(String term, String variable)

===Parameter===
* '''term''' - der zu überprüfende Ausdruck
* '''variable''' - die Variable

===Return Value===
* Gibt einen Boolean zurück.

===Beispiele===
isPolynomial('x^2+x+1','x') --> returns ''true''

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
OMOBJ x = new OMOBJ();
OMOBJ y = new OMOBJ();
x.setOMV(OMCreator.createOMV("x"));
y.setOMV(OMCreator.createOMV("y"));

fillIn.put(1, x);
fillIn.put(2, y);

exerVar.put("a", x);
exerVar.put("b", y);
}

@Test
public void testIsPolynomial1() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('x^2+x+1','x')", exerVar, fillIn));
}

@Test
public void testIsPolynomial2() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('y^2+3*y+4','y')", exerVar, fillIn));
}

@Test
public void testIsPolynomial3() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('3*a^5+2*a^3-a','a')", exerVar, fillIn));
}

@Test
public void testIsPolynomial4() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('m^3+2*m-2','m')", exerVar, fillIn));
}

@Test
public void testIsPolynomial5() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('x^2+x+1','y')", exerVar, fillIn));
}

@Test
public void testIsPolynomial6() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('x','x')", exerVar, fillIn));
}

@Test
public void testIsPolynomial7() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('sin(x)+ y^3', 'y')", exerVar, fillIn));
}

@Test
public void testIsPolynomial8() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('e^(x) + y^3', 'y')", exerVar, fillIn));
}

@Test
public void testIsPolynomial9() {
assertEquals(false, Evaluator.getBooleanResult("isPolynomial('sin(x)+ y^3', 'x')", exerVar, fillIn));
}

@Test
public void testIsPolynomial10() {
assertEquals(false, Evaluator.getBooleanResult("isPolynomial('e^(x) + y^3', 'x')", exerVar, fillIn));
}

@Test
public void testIsPolynomialWithInput() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('x^2+x+1','[pos=1]')", exerVar, fillIn));
}

@Test
public void testIsPolynomialWithVariables() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('x^2+x+1','[var=a]')", exerVar, fillIn));
}

@Test // (expected=AssertionError.class)
public void testIsPolynomialWithNumberAsSecondArgument1() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('sin(x)', '1')", exerVar, fillIn));// Look if 1 is
// Polynomial
}

@Test // (expected=AssertionError.class)
public void testIsPolynomialWithNumberAsSecondArgument2() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('e^(x)', '0')", exerVar, fillIn)); // Look if 0 is
// Polynomial
}

@Test // (expected=AssertionError.class)
public void testIsPolynomialWithNumberAsSecondArgument3() {
assertEquals(true, Evaluator.getBooleanResult("isPolynomial('x^2+x+1','2')", exerVar, fillIn));// Look if 2 is
// Polynomial
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testIsPolynomialWithEmptyStringArguments() {
Evaluator.getBooleanResult("isPolynomial('', '')", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIsPolynomialWithEmptyArgument() {
Evaluator.getBooleanResult("isPolynomial()", exerVar, fillIn);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testIsPolynomialWithoutExerciseVariable() {
Evaluator.getBooleanResult("isPolynomial('[var=j]', '[var=j]')", exerVar, fillIn);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testIsPolynomialWithoutInput() {
Evaluator.getBooleanResult("isPolynomial('[pos=42]', '[pos=42]')", exerVar, fillIn);
}
</syntaxhighlight>

===Hinweise===
* Der Ausdruck muss ein Polynom sein!

[[Kategorie:Evaluatorfunktion]]

IsRealNumber

2017-09-18T11:04:07Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''isNumber'' prüft, ob es sich bei einer gegebenen Zeichenkette um eine Zahl handelt. Die Funktion erwartet einen String und gibt einen Boolean zurück.

=== Syntax ===
isNumber(String zeichenkette)

=== Parameter ===
* '''zeichenkette''' - der zu überprüfende String

=== Return Value ===
* Gibt einen Boolean zurück

=== Beispiele ===
==== Standardfälle ====
isNumber('15.3') --> returns true
isNumber('zahl') --> returns false

==== Benutzung von Variablen ====
isNumber('[pos=1]')
isNumber('[var=a]')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
OMOBJ zero = new OMOBJ();
OMOBJ mTwelve = new OMOBJ();
OMOBJ twoHundred = new OMOBJ();
zero.setOMI(OMCreator.createOMI(0));
mTwelve.setOMI(OMCreator.createOMI(-12));
twoHundred.setOMI(OMCreator.createOMI(200));

exerVar.put("a", twoHundred);
exerVar.put("b", zero);
exerVar.put("c", mTwelve);

fillIn.put(1, twoHundred);
fillIn.put(2, zero);
fillIn.put(3, mTwelve);
}

@Test
public void testIsNumber1() {
assertEquals(true, Evaluator.getBooleanResult("isNumber('10')", exerVar, fillIn));
}

@Test
public void testIsNumber2() {
assertEquals(true, Evaluator.getBooleanResult("isNumber('1234567890')", exerVar, fillIn));
}

@Test
public void testIsNumber3() {
assertEquals(true, Evaluator.getBooleanResult("isNumber('-101230')", exerVar, fillIn));
}

@Test
public void testIsNumber4() {
assertEquals(false, Evaluator.getBooleanResult("isNumber('12$56&')", exerVar, fillIn));
}

@Test
public void testIsNumber5() {
assertEquals(false, Evaluator.getBooleanResult("isNumber('&!รยง$%&/()123asdf')", exerVar, fillIn));
}

@Test
public void testIsNumber6() {
assertEquals(false, Evaluator.getBooleanResult("isNumber('abcde')", exerVar, fillIn));
}

@Test
public void testIsNumberWithInput1() {
assertEquals(true, Evaluator.getBooleanResult("isNumber('[pos=1]')", exerVar, fillIn));
}

@Test
public void testIsNumberWithInput2() {
assertEquals(true, Evaluator.getBooleanResult("isNumber('[pos=2]')", exerVar, fillIn));
}

@Test
public void testIsNumberWithInput3() {
assertEquals(true, Evaluator.getBooleanResult("isNumber('[pos=3]')", exerVar, fillIn));
}

@Test
public void testIsNumberWithVariables1() {
assertEquals(true, Evaluator.getBooleanResult("isNumber('[var=a]')", exerVar, fillIn));
}

@Test
public void testIsNumberWithVariables2() {
assertEquals(true, Evaluator.getBooleanResult("isNumber('[var=b]')", exerVar, fillIn));
}

@Test
public void testIsNumberWithVariables3() {
assertEquals(true, Evaluator.getBooleanResult("isNumber('[var=c]')", exerVar, fillIn));
}

@Test
public void testIsNumberWithWrongInputCharacter() {
assertEquals(false, Evaluator.getBooleanResult("isNumber(a)", exerVar, fillIn));
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIsNumberWithTwoArguments() {
Evaluator.getBooleanResult("isNumber(3/2 , 0)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIsNumberWithThreeArguments() {
Evaluator.getBooleanResult("isNumber(3/2, 1/3, 3/1)", exerVar, fillIn);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testIsNumberWithMissingExerciseVariable() {
Evaluator.getBooleanResult("isNumber('[var=j]')", exerVar, fillIn);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testIsNumberWithMissingInput() {
Evaluator.getBooleanResult("isNumber('[pos=42]')", exerVar, fillIn);
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

IsLinearlyIndependent

2017-09-18T11:03:38Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktion ''isLinearlyIndependent'' testet, ob Vektoren linear unabhägig sind. Die Funktion erwartet eine Menge von Vektoren und gibt einen boolean zurück.

===Syntax===
isLinearlyIndependent(String vektoren)

===Parameter===
* '''vektoren''' - Menge von Vektoren, die auf lineare Unabhängigkeit geprüft werden sollen

===Return Value===
* Gibt einen boolean zurück

===Beispiele===
isLinearlyIndependent(set(vector(1,1), vector(1,2))) --> returns true

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

// set(vector(1,2,3),vector(3,3,3))
isLinearlyIndependentFillInVariableMap.put(1, OMConverter.toObject(
"<OMOBJ><OMA><OMS cd='list1' name='list'/><OMA><OMS cd='linalg2' name='vector'/><OMI>1</OMI><OMI>2</OMI><OMI>3</OMI></OMA><OMA><OMS cd='linalg2' name='vector'/><OMI>3</OMI><OMI>3</OMI><OMI>3</OMI></OMA></OMA></OMOBJ>"));
isLinearlyIndependentFillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMI>1</OMI></OMOBJ>"));

// set(vector(1,2,3),vector(3,3,3))
isLinearlyIndependentExerciseVariableMap.put("a", OMConverter.toObject(
"<OMOBJ><OMA><OMS cd='list1' name='list'/><OMA><OMS cd='linalg2' name='vector'/><OMI>1</OMI><OMI>2</OMI><OMI>3</OMI></OMA><OMA><OMS cd='linalg2' name='vector'/><OMI>3</OMI><OMI>3</OMI><OMI>3</OMI></OMA></OMA></OMOBJ>"));
isLinearlyIndependentExerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMI>1</OMI></OMOBJ>"));

}

@Test
public void testIsLinearlyIndependent1() {
assertTrue(Evaluator.getBooleanResult("isLinearlyIndependent(set(vector(1,1), vector(1,2)))",
isLinearlyIndependentExerciseVariableMap, isLinearlyIndependentFillInVariableMap));
}

@Test
public void testIsLinearlyIndependent2() {
assertTrue(Evaluator.getBooleanResult("isLinearlyIndependent(set(vector(1)))",
isLinearlyIndependentExerciseVariableMap, isLinearlyIndependentFillInVariableMap));
}

@Test
public void testIsLinearlyIndependent3() {
assertTrue(Evaluator.getBooleanResult("isLinearlyIndependent(set(vector(1,1,0), vector(1,1,1)))",
isLinearlyIndependentExerciseVariableMap, isLinearlyIndependentFillInVariableMap));
}

@Test
public void testIsLinearlyIndependent4() {
assertTrue(Evaluator.getBooleanResult(
"isLinearlyIndependent(set(vector(1,0,0), vector(1,1,1), vector(1.5, 1.5, 1.8)))",
isLinearlyIndependentExerciseVariableMap, isLinearlyIndependentFillInVariableMap));
}

@Test
public void testIsLinearlyIndependent5() {
assertTrue(Evaluator.getBooleanResult("isLinearlyIndependent(set(vector(1,2,3), vector(3,3,3)))",
isLinearlyIndependentExerciseVariableMap, isLinearlyIndependentFillInVariableMap));
}

@Test
public void testIsLinearlyIndependentWithInput1() {
assertTrue(Evaluator.getBooleanResult("isLinearlyIndependent(set(vector(1,[pos=2],0), vector(1,1,[pos=2])))",
isLinearlyIndependentExerciseVariableMap, isLinearlyIndependentFillInVariableMap));
}

@Test
public void testIsLinearlyIndependentWithInput2() {
assertTrue(Evaluator.getBooleanResult("isLinearlyIndependent('[pos=1]')",
isLinearlyIndependentExerciseVariableMap, isLinearlyIndependentFillInVariableMap));
}

@Test
public void testIsLinearlyIndependentWithVariables1() {
assertTrue(Evaluator.getBooleanResult("isLinearlyIndependent(set(vector(1,[var=b],0), vector(1,1,[var=b])))",
isLinearlyIndependentExerciseVariableMap, isLinearlyIndependentFillInVariableMap));
}

@Test
public void testIsLinearlyIndependentWithVariables2() {
assertTrue(Evaluator.getBooleanResult("isLinearlyIndependent('[var=a]')",
isLinearlyIndependentExerciseVariableMap, isLinearlyIndependentFillInVariableMap));
}

@Test(expected = ParserException.class)
public void TestIsLinearlyIndependentWithWrongInputONECharacter() {
Evaluator.getBooleanResult("isLinearlyIndependent(ba)", isLinearlyIndependentExerciseVariableMap,
isLinearlyIndependentFillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testIsLinearlyIndependentWithEmptyStringArgument() {
Evaluator.getBooleanResult("isLinearlyIndependent('')", isLinearlyIndependentExerciseVariableMap,
isLinearlyIndependentFillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIsLinearlyIndependentWithEmptyArgument() {
Evaluator.getBooleanResult("isLinearlyIndependent()", isLinearlyIndependentExerciseVariableMap,
isLinearlyIndependentFillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testIsLinearlyIndependentWithoutExerciseVariable() {
Evaluator.getBooleanResult("isLinearlyIndependent('[var=j]')", isLinearlyIndependentExerciseVariableMap,
isLinearlyIndependentFillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testIsLinearlyIndependentWithoutInput() {
Evaluator.getBooleanResult("isLinearlyIndependent('[pos=42]')", isLinearlyIndependentExerciseVariableMap,
isLinearlyIndependentFillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===
* Die Funktionen [[Set]] und [[vector]] setzen die Vektoren in die richtige Schreibweise.

[[Kategorie:Evaluatorfunktion]]

IsFraction

2017-09-18T11:03:18Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''isFraction'' prüft, ob es sich bei einem String bezüglich des Aufbaus um einen Bruch handelt. Die Funktion erwartet einen String, der darauf geprüft wird, ob er wie ein Bruch aufgebaut ist, und gibt einen Boolean zurück.

=== Syntax ===
isFraction(String zeichenkette)

=== Parameter ===
* '''zeichenkette''' - der zu prüfende String

=== Return Value ===
* Gibt einen Boolean zurück

=== Beispiele ===
==== Standardfälle ====
isFraction('7/9') --> returns true
isFraction('10.76') --> returns false

==== Benutzung von Variablen ====
isFraction('[pos=1]')
isFraction('[var=a]')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
OMOBJ six = new OMOBJ();
six.setOMI(OMCreator.createOMI(6));

exerVar.put("a", OMConverter
.toObject("<OMOBJ><OMA><OMS name=\"divide\" cd=\"arith1\" /><OMI>1</OMI><OMI>5</OMI></OMA></OMOBJ>"));
exerVar.put("b", OMConverter
.toObject("<OMOBJ><OMA><OMS name=\"divide\" cd=\"arith1\" /><OMI>10</OMI><OMI>2</OMI></OMA></OMOBJ>"));
exerVar.put("c", OMConverter
.toObject("<OMOBJ><OMA><OMS name=\"divide\" cd=\"arith1\" /><OMI>7</OMI><OMI>9</OMI></OMA></OMOBJ>"));
exerVar.put("d", six);

fillIn.put(1, OMConverter
.toObject("<OMOBJ><OMA><OMS name=\"divide\" cd=\"arith1\" /><OMI>1</OMI><OMI>5</OMI></OMA></OMOBJ>"));
fillIn.put(2, OMConverter
.toObject("<OMOBJ><OMA><OMS name=\"divide\" cd=\"arith1\" /><OMI>10</OMI><OMI>2</OMI></OMA></OMOBJ>"));
fillIn.put(3, OMConverter
.toObject("<OMOBJ><OMA><OMS name=\"divide\" cd=\"arith1\" /><OMI>7</OMI><OMI>9</OMI></OMA></OMOBJ>"));
fillIn.put(4, six);
}

@Test
public void testIsFraction1() {
assertEquals(true, Evaluator.getBooleanResult("isFraction(1/3)", exerVar, fillIn));
}

@Test
public void testIsFraction2() {
assertEquals(true, Evaluator.getBooleanResult("isFraction(7/10)", exerVar, fillIn));
}

@Test
public void testIsFraction3() {
assertEquals(true, Evaluator.getBooleanResult("isFraction(90/65)", exerVar, fillIn));
}

@Test
public void testIsFraction4() {
assertEquals(true, !Evaluator.getBooleanResult("isFraction(1)", exerVar, fillIn));
}

@Test
public void testIsFraction5() {
assertEquals(true, !Evaluator.getBooleanResult("isFraction(10.76)", exerVar, fillIn));
}

@Test
public void testIsFractionWithInput1() {
assertEquals(true, Evaluator.getBooleanResult("isFraction([pos=1])", exerVar, fillIn));
}

@Test
public void testIsFractionWithInput2() {
assertEquals(true, Evaluator.getBooleanResult("isFraction([pos=2])", exerVar, fillIn));
}

@Test
public void testIsFractionWithInput3() {
assertEquals(true, Evaluator.getBooleanResult("isFraction([pos=3])", exerVar, fillIn));
}

@Test
public void testIsFractionWithInput4() {
assertEquals(true, !Evaluator.getBooleanResult("isFraction([pos=4])", exerVar, fillIn));
}

@Test
public void testIsFractionWithVariables1() {
assertEquals(true, Evaluator.getBooleanResult("isFraction([var=a])", exerVar, fillIn));
}

@Test
public void testIsFractionWithVariables2() {
assertEquals(true, Evaluator.getBooleanResult("isFraction([var=b])", exerVar, fillIn));
}

@Test
public void testIsFractionWithVariables3() {
assertEquals(true, Evaluator.getBooleanResult("isFraction([var=c])", exerVar, fillIn));
}

@Test
public void testIsFractionWithVariables4() {
assertEquals(true, !Evaluator.getBooleanResult("isFraction([var=d])", exerVar, fillIn));
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testIsFractionWithWrongInputCharacter() {
Evaluator.getBooleanResult("isFraction(a)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIsFractionWithTwoArguments() {
Evaluator.getBooleanResult("isFraction(3/2 , 0)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIsFractionWithThreeArguments() {
Evaluator.getBooleanResult("isFraction(3/2, 1/3, 3/1)", exerVar, fillIn);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testIsFractionWithMissingExerciseVariable() {
Evaluator.getBooleanResult("isFraction('[var=j]')", exerVar, fillIn);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testIsFractionWithMissingInput() {
Evaluator.getBooleanResult("isFraction('[pos=42]')", exerVar, fillIn);
}
</syntaxhighlight>

=== Hinweise ===
* Auch wenn sich jede rationale Zahl natürlich als Bruch darstellen lässt, wird bei dieser Funktion explizit der Aufbau des Strings überprüft.

[[Kategorie:Evaluatorfunktion]]

IsEmpty

2017-09-18T11:02:53Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''isEmpty'' prüft ob eine gegebene Zeichenkette leer ist, also entweder keine Zeichen oder ausschließlich Leerzeichen beinhaltet. Die Funktion erwartet einen String und gibt einen Boolean zurück.

=== Syntax ===
isEmpty(String zeichenkette)

=== Parameter ===
* '''zeichenkette''' - String, der auf leeren Inhalt geprüft wird

=== Return Value ===
* Gibt einen Boolean zurück

=== Beispiele ===
==== Standardfälle ====
isEmpty(' ') --> returns true
isEmpty('nichtleer') --> returns false

==== Benutzung von Variablen ====
isEmpty('[pos=1]')
isEmpty('[var=a]')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
OMOBJ one = new OMOBJ();
one.setOMI(OMCreator.createOMI(1));
fillIn.put(2, one);
exerVar.put("b", one);
}

@Test
public void testIsEmpty1() {
assertEquals(true, Evaluator.getBooleanResult("isEmpty('')", exerVar, fillIn));
}

@Test
public void testIsEmpty2() {
assertEquals(false, Evaluator.getBooleanResult("isEmpty(' ')", exerVar, fillIn));
}

@Test
public void testIsEmpty3() {
assertEquals(false, Evaluator.getBooleanResult("isEmpty('a')", exerVar, fillIn));
}

@Test
public void testIsEmpty4() {
assertEquals(false, Evaluator.getBooleanResult("isEmpty('5')", exerVar, fillIn));
}

@Test
public void testIsEmptyWithInput() {
assertEquals(false, Evaluator.getBooleanResult("isEmpty('[pos=2]')", exerVar, fillIn));
}

@Test
public void testIsEmptyWithVariables() {
assertEquals(false, Evaluator.getBooleanResult("isEmpty('[var=b]')", exerVar, fillIn));
}

@Test
public void testIsEmptyWithWrongInputCharacter() {
assertEquals(false, Evaluator.getBooleanResult("isEmpty(a)", exerVar, fillIn));
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIsEmptyWithTwoArguments() {
Evaluator.getBooleanResult("isEmpty('a', 0)", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIsEmptyWithThreeArguments() {
Evaluator.getBooleanResult("isEmpty('string', 1, 3)", exerVar, fillIn);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testIsEmptyWithMissingExerciseVariable() {
Evaluator.getBooleanResult("isEmpty('[var=j]')", exerVar, fillIn);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testIsEmptyWithMissingInput() {
Evaluator.getBooleanResult("isEmpty('[pos=42]')", exerVar, fillIn);
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

Integrate

2017-09-18T11:02:34Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktion ''integrate'' integriert eine Funktion. Sie erwartet zwei Strings, den Ausdruck der integriert werden soll und die Variable nach der integriert werden soll. Die Funktion gibt einen String zurück.

===Syntax===
integrate(String term, String variable)

===Parameter===
* '''term''' - die Funktion die integriert werden soll
* '''variable''' - die Variable nach der integriert werden soll

===Return Value===
* Gibt den String zurück der die integrierte Funktion darstellt.

===Beispiele===
integrate('2','x') --> returns 2x

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() throws FunctionNotImplementedException, UndefinedFillInVariableException,
UndefinedExerciseVariableException, ParserException, ErroneousFillInVariableException, ErroneousExerciseVariableException {
integrateFillInVariableMap.put(1, ExpressionParser.parse("2", null, null));
integrateFillInVariableMap.put(2, ExpressionParser.parse("1", null, null));

integrateExerciseVariableMap.put("a", ExpressionParser.parse("2", null, null));
integrateExerciseVariableMap.put("b", ExpressionParser.parse("1", null, null));
}

@Test
public void testIntegrate1() {
assertEquals(ExpressionParser.parse("2*x", null, null), Evaluator.evaluate(
"integrate('2','x')", integrateExerciseVariableMap, integrateFillInVariableMap));
}

@Test
public void testIntegrate2() {
assertEquals(ExpressionParser.parse("2*y", null, null), Evaluator.evaluate(
"integrate('2','y')", integrateExerciseVariableMap, integrateFillInVariableMap));
}

@Test
public void testIntegrateWithInput1() {
assertEquals(ExpressionParser.parse("2*x", null, null), Evaluator.evaluate(
"integrate('[pos=1]','x')", integrateExerciseVariableMap, integrateFillInVariableMap));
}

@Test
public void testIntegrateWithInput2() {
assertEquals(ExpressionParser.parse("y", null, null), Evaluator.evaluate(
"integrate('[pos=2]','y')", integrateExerciseVariableMap, integrateFillInVariableMap));
}

@Test
public void testIntegrateWithVariables1() {
assertEquals(ExpressionParser.parse("2*x", null, null), Evaluator.evaluate(
"integrate('[var=a]','x')", integrateExerciseVariableMap, integrateFillInVariableMap));
}

@Test
public void testIntegrateWithVariables2() {
assertEquals(ExpressionParser.parse("y", null, null), Evaluator.evaluate(
"integrate('[var=b]','y')", integrateExerciseVariableMap, integrateFillInVariableMap));
}

@Test
public void testIntegrateWithONECharacter() {
ArrayList<Object> rational = new ArrayList<>();
rational.add(OMCreator.createOMI(1));
rational.add(OMCreator.createOMI(2));

ArrayList<Object> power = new ArrayList<>();
power.add(OMCreator.createOMV("a"));
power.add(OMCreator.createOMI(2));

ArrayList<Object> expected = new ArrayList<>();
expected.add(OMCreator.createOMA(OMSymbol.NUMS1_RATIONAL, rational));
expected.add(OMCreator.createOMA(OMSymbol.ARITH1_POWER, power));

OMOBJ expect = OMCreator.createOMOBJ(OMCreator.createOMA(OMSymbol.ARITH1_TIMES, expected));
//Creating OMOBJ (1/2)*(a^2) --> This is also a correct answer!

assertEquals(expect, Evaluator.evaluate(
"integrate(a, a)", integrateExerciseVariableMap, integrateFillInVariableMap));
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testIntegrateWithEmptyStringArguments() {
Evaluator.evaluate("integrate('','')", integrateExerciseVariableMap,
integrateFillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIntegrateWithEmptyArgument() {
Evaluator.evaluate("integrate()", integrateExerciseVariableMap, integrateFillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testIntegrateWithMissingExerciseVariable() {
Evaluator.getNumberResult("integrate('y', '[var=j]')", integrateExerciseVariableMap,
integrateFillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testIntegrateWithMissingInput() {
Evaluator.getNumberResult("integrate('y', '[pos=42]')", integrateExerciseVariableMap,
integrateFillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===

[[Kategorie:Evaluatorfunktion]]

IndexOf

2017-09-18T11:02:13Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''indexOf'' bestimmt die Position, an der eine Zeichenkette oder ein einzelnes Zeichen innerhalb einer anderen Zeichenkette das erste Mal vorkommt. Außerdem muss angegeben werden, ab welcher Stelle gesucht werden soll. Die Funktion erwartet zwei Strings, die zu durchsuchende und die zu suchende Zeichenkette, und eine Ganzzahl, ab welcher Stelle die Suche beginnen soll. Es wird eine Ganzzahl zurückgegeben.

=== Syntax ===
indexOf(String zeichenkette, String muster, int position)

=== Parameter ===
* '''zeichenkette''' - Zeichenkette in dem gesucht wird
* '''muster''' - Zeichenkette, die innnerhalb der ersten gesucht wird
* '''position''' - Startpositition der Suche

=== Return Value ===
* Gibt eine Ganzzahl zurück

=== Beispiele ===
==== Standardfälle ====
indexOf('Hello World!','o',0) --> returns 4
indexOf('Hello World!','o',6) --> returns 7

==== Benutzung von Variablen ====
indexOf('[pos=1]','x',0)
indexOf('text','[var=a]',0)
indexOf('[var=b]','x',[pos=2])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(7, OMConverter.toObject("<OMOBJ><OMSTR>str</OMSTR></OMOBJ>"));
fillInVariableMap.put(8, OMConverter.toObject("<OMOBJ><OMSTR>anotherstring</OMSTR></OMOBJ>"));
fillInVariableMap.put(9, OMConverter.toObject("<OMOBJ><OMI>2</OMI></OMOBJ>"));

exerciseVariableMap.put("g", OMConverter.toObject("<OMOBJ><OMSTR>str</OMSTR></OMOBJ>"));
exerciseVariableMap.put("h", OMConverter.toObject("<OMOBJ><OMSTR>anotherstring</OMSTR></OMOBJ>"));
exerciseVariableMap.put("i", OMConverter.toObject("<OMOBJ><OMI>2</OMI></OMOBJ>"));

}

@Test
public void testIndexOf1() {
assertEquals(3, Evaluator.getNumberResult("indexOf('abcdef','def', 0)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testIndexOf2() {
assertEquals(4, Evaluator.getNumberResult("indexOf('abc def','def', 2)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testIndexOf3() {
assertEquals(4, Evaluator.getNumberResult("indexOf('abc_def','def', 3)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testIndexOf4() {
assertEquals(4, Evaluator.getNumberResult("indexOf('2 c 4e6','4e6', 1)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test (expected=FunctionInvalidArgumentException.class)
public void testIndexOf5() {
assertEquals(-1, Evaluator.getNumberResult("indexOf('2c4e 6','4e6', -1)", exerciseVariableMap, fillInVariableMap),0.0);
fail();
}

@Test
public void testIndexOfWithInput1() {
assertEquals(7, Evaluator.getNumberResult("indexOf('[pos=8]','str', 3)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testIndexOfWithInput2() {
assertEquals(7, Evaluator.getNumberResult("indexOf('[pos=8]','[pos=7]', 2)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testIndexOfWithInput3() {
assertEquals(7, Evaluator.getNumberResult("indexOf('[pos=8]','[pos=7]', [pos=9])", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testIndexOfWithVariables1() {
assertEquals(7, Evaluator.getNumberResult("indexOf('[var=h]','str', 3)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testIndexOfWithVariables2() {
assertEquals(7, Evaluator.getNumberResult("indexOf('[var=h]','[var=g]', 2)", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testIndexOfWithVariables3() {
assertEquals(7, Evaluator.getNumberResult("indexOf('[var=h]','[var=g]', [var=i])", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test
public void testIndexOfWithArgumentAsInputPointNumber() {
assertEquals(OMCreator.createOMI(-1),Evaluator.evaluate("indexOf('abcdr5', 5.1, 1)", exerciseVariableMap, fillInVariableMap).getOMI());
}

@Test
public void testIndexOfWithWrongInputCharacter() {
assertEquals(-1, Evaluator.getNumberResult("indexOf('abcd5', a, 1)", exerciseVariableMap, fillInVariableMap),0.0);

}

@Test
public void testIndexOfWithTwoRationalAndOneTextArguments() {
assertEquals(4, Evaluator.getNumberResult("indexOf('abcd5', 5, 1)", exerciseVariableMap, fillInVariableMap),0.0);

}

@Test
public void testIndexOfWithThreeRationalArguments() {
assertEquals(0,Evaluator.getNumberResult("indexOf(5, 5, 0)", exerciseVariableMap, fillInVariableMap),0.0);

}

@Test
public void testIndexOfWithThreeTextArguments() {
assertEquals(3.0 , Evaluator.getNumberResult("indexOf('abcstr', 'str', '0')", exerciseVariableMap, fillInVariableMap),0.0);
}

@Test(expected=FunctionInvalidNumberOfArgumentsException.class)
public void testIndexOfWithOneArgument() {
Evaluator.getNumberResult("indexOf(1)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test
public void testIndexOfWithTwoArguments() {
assertEquals(OMCreator.createOMI(-1),Evaluator.evaluate("indexOf('string', 1)", exerciseVariableMap, fillInVariableMap).getOMI());

}

@Test(expected=UndefinedExerciseVariableException.class)
public void testIndexOfWithMissingExerciseVariable() {
Evaluator.getNumberResult("indexOf('[var=j]', 'str', 2)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected=UndefinedFillInVariableException.class)
public void testIndexOfWithMissingInput() {
Evaluator.getNumberResult("indexOf('[pos=42]', 'str', 2)", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===
* Die Nummerierung innerhalb der Zeichenkette beginnt mit 0.
* Sollte die gesuchte Zeichenkette nicht gefunden werden, gibt die Funktion -1 zurück.

[[Kategorie:Evaluatorfunktion]]

Ifthenelse

2017-09-18T11:01:37Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''ifthenelse'' wählt zwischen zwei Zeichenketten, abhängig vom logischen Wahrheitsgehalt einer gegebenen Aussage. Als Aussage sind rationale Zahlen, sowie mathematische Terme und Un-/Gleichungen zulässig. Zahlen ungleich 0 werden als ''wahr'', 0 wird zu ''falsch'' ausgewertet.

Die Funktion erwartet eine Aussage, die sich zu ''wahr'' oder ''falsch'' auswerten lässt, einen String, der zurückgegeben wird, falls die Aussage ''wahr'' ist, und einen String, der zurückgegeben wird, falls die Aussage ''falsch'' ist. Es wird ein String zurückgegeben.

=== Syntax ===
ifthenelse(String aussage, String wahrAussage, String falschAussage)

=== Parameter ===
* '''aussage''' - logisch auzuwertende Aussage
* '''wahrAussage''' - String, der im Falle einer wahren Aussage zurückgegeben wird
* '''falschAussage''' - String, der im Falle einer falschen Aussage zurückgegeben wird

=== Return Value ===
* Gibt einen String zurück

=== Beispiele ===
==== Standardfälle ====
ifthenelse('1','wahr','falsch') --> returns wahr
ifthenelse('5*2+5==5*3','a','b') --> returns a

==== Benutzung von Variablen ====
ifthenelse('[pos=1]','then','else')
ifthenelse('15','[var=a]','text')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(7, OMConverter.toObject("<OMOBJ><OMSTR>test</OMSTR></OMOBJ>"));

exerciseVariableMap.put("g", OMConverter.toObject("<OMOBJ><OMSTR>test</OMSTR></OMOBJ>"));

}

@Test
public void testIfthenelse1() {
assertEquals(ExpressionParser.parse("'else'", null, null),
Evaluator.evaluate("ifthenelse(0, 'then', 'else')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testIfthenelse2() {
assertEquals(ExpressionParser.parse("'then'", null, null),
Evaluator.evaluate("ifthenelse(1, 'then', 'else')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testIfthenelse3() {
assertEquals(ExpressionParser.parse("'five'", null, null),
Evaluator.evaluate("ifthenelse(5.7, 'five', 'notFive')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testIfthenelseWithInput1() {
assertEquals(ExpressionParser.parse("'else'", null, null),
Evaluator.evaluate("ifthenelse([pos=1], 'then', 'else')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testIfthenelseWithInput2() {
assertEquals(ExpressionParser.parse("'test'", null, null),
Evaluator.evaluate("ifthenelse(1, '[pos=7]', 'else')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testIfthenelseWithInput3() {
assertEquals(ExpressionParser.parse("'test'", null, null), Evaluator
.evaluate("ifthenelse([pos=2], '[pos=7]', 'notFive')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testIfthenelseWithVariables1() {
assertEquals(ExpressionParser.parse("'else'", null, null),
Evaluator.evaluate("ifthenelse([var=a], 'then', 'else')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testIfthenelseWithVariables2() {
assertEquals(ExpressionParser.parse("'test'", null, null),
Evaluator.evaluate("ifthenelse(1, '[var=g]', 'else')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testIfthenelseWithVariables3() {
assertEquals(ExpressionParser.parse("'test'", null, null), Evaluator
.evaluate("ifthenelse([var=b], '[var=g]', 'notFive')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testIfthenelseWithExpressions1() {
assertEquals(ExpressionParser.parse("a", null, null),
Evaluator.evaluate("ifthenelse('5*2 +5 == 5*3', 'a', 'b')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testIfthenelseWithExpressions2() {
assertEquals(ExpressionParser.parse("b", null, null), Evaluator
.evaluate("ifthenelse(ifthenelse(0, '1', '0'), 'a', 'b')", exerciseVariableMap, fillInVariableMap));
}

@Test(expected = ParserException.class)
public void testIfthenelseWithWrongInputCharacter() {
Evaluator.evaluate("ifthenelse(ab, 'a', 'b')", exerciseVariableMap, fillInVariableMap);
}

@Test
public void testIfthenelseWithTwoRationalAndOneTextArgument() {
assertEquals(ExpressionParser.parse("0", null, null), Evaluator.evaluate("ifthenelse(1, 0, 'b')", exerciseVariableMap, fillInVariableMap));
}

@Test
public void testIfthenelseWithThreeRationalArguments() {
assertEquals(ExpressionParser.parse("0", null, null), Evaluator.evaluate("ifthenelse(1, 0, 7)", exerciseVariableMap, fillInVariableMap));
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIfthenelseWithOneArgument() {
Evaluator.evaluate("ifthenelse(1)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIfthenelseWithTwoArguments() {
Evaluator.evaluate("ifthenelse(0, 'this')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testIfthenelseWithMissingExerciseVariable() {
Evaluator.evaluate("ifthenelse('[var=j]', 'a', 'b')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testIfthenelseWithMissingInput() {
Evaluator.evaluate("ifthenelse('[pos=42]', 'a', 'b')", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===
* Zahlen ungleich 0 werden zu ''wahr'' ausgewertet.

[[Kategorie:Evaluatorfunktion]]

IEEERemainder

2017-09-18T11:01:18Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===

Die Funktion ''IEEEremainder'' berechnet die Remainder-Operation auf zwei Argumente, wie es in dem IEEE 745 Standtard beschrieben ist [https://de.wikipedia.org/wiki/IEEE_754#Aritmetik_und_Quadratwurzel]. Die Funktion erwartet zwei Zahlen und gibt das entsprechende Ergebnis zurück.

=== Syntax ===
IEEEremainder(float f1, float f2)

=== Parameter ===
* '''f1''' - Zähler
* '''f2''' - Nenner

=== Return Value ===
*Gibt den Rest-Wert zurück, wenn f1 durch f2 geteilt wird

=== Beispiele ===
==== Standardfälle ====
IEEEremainder(4,2) --> returns 0
IEEEremainder(3,2) --> returns -1

==== Benutzung mit Variablen ====
IEEEremainder([pos=1],[pos=2])
IEEEremainder([var=a],[var=b])

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {

fillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMI>0</OMI></OMOBJ>"));
fillInVariableMap.put(2, OMConverter.toObject("<OMOBJ><OMI>20</OMI></OMOBJ>"));
fillInVariableMap.put(3, OMConverter.toObject("<OMOBJ><OMI>-10</OMI></OMOBJ>"));

exerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMI>0</OMI></OMOBJ>"));
exerciseVariableMap.put("b", OMConverter.toObject("<OMOBJ><OMI>20</OMI></OMOBJ>"));
exerciseVariableMap.put("c", OMConverter.toObject("<OMOBJ><OMI>-10</OMI></OMOBJ>"));

}

@Test
public void testIEEERemainder1() {
assertEquals(-1, Evaluator.getNumberResult("IEEEremainder(3, 2)", exerciseVariableMap, fillInVariableMap), 0);
}

@Test
public void testIEEERemainder2() {
assertEquals(0, Evaluator.getNumberResult("IEEEremainder(4, 2)", exerciseVariableMap, fillInVariableMap), 0);
}

@Test
public void testIEEERemainder3() {
assertEquals(1, Evaluator.getNumberResult("IEEEremainder(10, 3)", exerciseVariableMap, fillInVariableMap), 0);
}

@Test
public void testIEEERemainder4() {
assertEquals(-1, Evaluator.getNumberResult("IEEEremainder(11, 3)", exerciseVariableMap, fillInVariableMap), 0);
}

@Test
public void testIEEERemainder5() {
assertEquals(-1, Evaluator.getNumberResult("IEEEremainder(27, 4)", exerciseVariableMap, fillInVariableMap), 0);
}

@Test
public void testIEEERemainder6() {
assertEquals(-2, Evaluator.getNumberResult("IEEEremainder(28, 5)", exerciseVariableMap, fillInVariableMap), 0);
}

@Test // It returns for Example 1.800000000XXX not 1.8
public void testIEEERemainderWithPointNumberResults1() {
assertEquals(1.8, Evaluator.getNumberResult("IEEEremainder(17.8, 4)", exerciseVariableMap, fillInVariableMap),
0.00001);
}

@Test
public void testIEEERemainderWithPointNumberResults2() {
assertEquals(1.4, Evaluator.getNumberResult("IEEEremainder(17.8, 4.1)", exerciseVariableMap, fillInVariableMap),
0.00001);
}

@Test
public void testIEEERemainderWithPointNumberResults3() {
assertEquals(0.1,
Evaluator.getNumberResult("IEEEremainder(-16.3, 4.1)", exerciseVariableMap, fillInVariableMap), 0.00001);
}

@Test
public void testIEEERemainderWithPointNumberResults4() {
assertEquals(1.4,
Evaluator.getNumberResult("IEEEremainder(17.8, -4.1)", exerciseVariableMap, fillInVariableMap), 0.00001);
}

@Test
public void testIEEERemainderWithPointNumberResults5() {
assertEquals(-1.4,
Evaluator.getNumberResult("IEEEremainder(-17.8, -4.1)", exerciseVariableMap, fillInVariableMap), 0.00001);
}

@Test
public void testIEEERemainderWithInput1() {
assertEquals(0, Evaluator.getNumberResult("IEEEremainder([pos=1], 4)", exerciseVariableMap, fillInVariableMap),
0);

}

@Test
public void testIEEERemainderWithInput2() {
assertEquals(0,
Evaluator.getNumberResult("IEEEremainder([pos=2], [pos=3])", exerciseVariableMap, fillInVariableMap),
0);
}

@Test
public void testIEEERemainderWithVariables1() {
assertEquals(0, Evaluator.getNumberResult("IEEEremainder([var=a], 4)", exerciseVariableMap, fillInVariableMap),
0);
}

@Test
public void testIEEERemainderWithVariables2() {
assertEquals(0,
Evaluator.getNumberResult("IEEEremainder([var=b], [var=c])", exerciseVariableMap, fillInVariableMap),
0);
}

@Test
public void testIEEERemainderWithExpressions1() {
assertEquals(0, Evaluator.getNumberResult("IEEEremainder('15', 'IEEEremainder(10, 3)')", exerciseVariableMap,
fillInVariableMap), 0);

}

@Test
public void testIEEERemainderWithExpressions2() {
assertEquals(0, Evaluator.getNumberResult("IEEEremainder('IEEEremainder(10, 3)', 'IEEEremainder(10, 3)')",
exerciseVariableMap, fillInVariableMap), 0);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testIEEERemainderWithWrongInputCharacter() {
Evaluator.getNumberResult("IEEEremainder(17.8, a)", exerciseVariableMap, fillInVariableMap);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIEEERemainderWithOneArgument() {
Evaluator.getNumberResult("IEEEremainder(8)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testIEEERemainderWithThreeArguments() {
Evaluator.getNumberResult("IEEEremainder(3, 2, 8)", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testIEEERemainderWithMissingExerciseVariable() {
Evaluator.getNumberResult("IEEEremainder('[var=j]', '3')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testIEEERemainderWithMissingInput() {
Evaluator.getNumberResult("IEEEremainder('[pos=42]', '3')", exerciseVariableMap, fillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidArgumentException.class)
public void testIEEERemainderAtZero() {
Evaluator.getNumberResult("IEEEremainder(5, 0)", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

GreaterThanOrEqual

2017-09-18T10:59:11Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktion ''greaterThanOrEqual'' vergleicht zwei Ausdrücke der Größe nach miteinander und gibt einen Wahrheitswert zurück, abhängig davon, ob der linksstehende Ausdruck größer-gleich dem rechtsstehenden Ausdruck ist.

===Syntax===
a >= b

===Parameter===
* '''a''' - double
* '''b''' - double

===Return Value===
* Gibt einen Boolean zurück.
*: Wenn der linke Ausdruck größer-gleich dem rechten Ausdruck ist, wird <code>true</code> zurückgegeben, andernfalls <code>false</code>.

===Beispiele===
<math>6 >= 3</math> --> returns ''true''

<math>3 >= 3</math> --> returns ''true''

<math>-1 >= 2</math> --> returns ''false''

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() throws FunctionNotImplementedException, UndefinedFillInVariableException,
UndefinedExerciseVariableException, ParserException, ErroneousFillInVariableException, ErroneousExerciseVariableException {
greaterThanOrEqualFillInVariableMap.put(1, ExpressionParser.parse("3", null, null));
greaterThanOrEqualFillInVariableMap.put(2, ExpressionParser.parse("1", null, null));

greaterThanOrEqualExerciseVariableMap.put("a", ExpressionParser.parse("8", null, null));
greaterThanOrEqualExerciseVariableMap.put("b", ExpressionParser.parse("25", null, null));
}

@Test
public void testGreaterThanOrEqual1() {
assertTrue(Evaluator.getBooleanResult("22>=8", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqual2() {
assertTrue(Evaluator.getBooleanResult("8>=8", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqual3() {
assertTrue(!Evaluator.getBooleanResult("2>=8", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqual4() {
assertTrue(Evaluator.getBooleanResult("9>=8", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqual5() {
assertTrue(!Evaluator.getBooleanResult("7>=45", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqual6() {
assertTrue(Evaluator.getBooleanResult("7>=7", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqual7() {
assertTrue(Evaluator.getBooleanResult("0>=-0.2", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqual8() {
assertTrue(Evaluator.getBooleanResult("0>=0", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithVariables1() {
assertTrue(Evaluator.getBooleanResult("22>=[var=a]", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithVariables2() {
assertTrue(!Evaluator.getBooleanResult("2>=[var=a]", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithVariables3() {
assertTrue(Evaluator.getBooleanResult("[var=b]>=8", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithVariables4() {
assertTrue(Evaluator.getBooleanResult("[var=a]>=8", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithVariables5() {
assertTrue(!Evaluator.getBooleanResult("23>=[var=b]", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithVariables6() {
assertTrue(Evaluator.getBooleanResult("[var=a]>=[var=a]", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithVariables7() {
assertTrue(Evaluator.getBooleanResult("[var=b]>=[var=a]", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithVariables8() {
assertTrue(!Evaluator.getBooleanResult("[var=a]>=[var=b]", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithInput1() {
assertTrue(Evaluator.getBooleanResult("22>=[pos=1]", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithInput2() {
assertTrue(Evaluator.getBooleanResult("3>=[pos=1]", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithInput3() {
assertTrue(!Evaluator.getBooleanResult("2>=[pos=1]", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithInput4() {
assertTrue(Evaluator.getBooleanResult("5>=[pos=2]", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithInput5() {
assertTrue(!Evaluator.getBooleanResult("[pos=2]>=5", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithInput6() {
assertTrue(!Evaluator.getBooleanResult("[pos=2]>=[pos=1]", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithEncapsulation1() {
assertTrue(Evaluator.getBooleanResult("1 >= (1 >= 2)", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithEncapsulation2() {
assertFalse(Evaluator.getBooleanResult("0 >= (0 >= (0 >= 1))", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithEncapsulation3() {
assertFalse(Evaluator.getBooleanResult("0 >= (0 >= (0 >= (0 >= (0 >= 1))))", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));
}

@Test
public void testGreaterThanOrEqualWithEncapsulation4() {
assertTrue(Evaluator.getBooleanResult("((((1 >= 1) >= 1) >= 1) >= 1) >= 1", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap));

}

@Test(expected=ParserException.class)
public void testGreaterThanOrEqualWithWrongInputCharacter() {
Evaluator.getBooleanResult("6 >= ab", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidArgumentTypeException.class)
public void testGreaterThanOrEqualWithWrongInputString() {
Evaluator.getBooleanResult("6 >= 'a'", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap);
fail();
}

@Test (expected=UndefinedExerciseVariableException.class)
public void testGreaterThanOrEqualWithMissingExcerciseVariable() {
Evaluator.getBooleanResult("[var=j] >= 2", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap);
fail();
}

@Test (expected=UndefinedFillInVariableException.class)
public void testGreaterThanOrEqualWithMissingInput() {
Evaluator.getBooleanResult("[pos=42] >= 2", greaterThanOrEqualExerciseVariableMap, greaterThanOrEqualFillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===

[[Kategorie:Evaluatorfunktion]]

GreaterThanOrEqual

2017-09-18T10:58:38Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktion ''greaterThanOrEqual'' vergleicht zwei Ausdrücke der Größe nach miteinander und gibt einen Wahrheitswert zurück, abhängig davon, ob der linksstehende Ausdruck größer-gleich dem rechtsstehenden Ausdruck ist.

===Syntax===
a >= b

===Parameter===
* '''a''' - double
* '''b''' - double

===Return Value===
* Gibt einen Boolean zurück.
*: Wenn der linke Ausdruck größer-gleich dem rechten Ausdruck ist, wird <code>true</code> zurückgegeben, andernfalls <code>false</code>.

===Beispiele===
<math>6 >= 3</math> --> returns ''true''

<math>3 >= 3</math> --> returns ''true''

<math>-1 >= 2</math> --> returns ''false''

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() throws FunctionNotImplementedException, UndefinedFillInVariableException,
UndefinedExerciseVariableException, ParserException, ErroneousFillInVariableException, ErroneousExerciseVariableException {
greaterThanFillInVariableMap.put(1, ExpressionParser.parse("3", null, null));
greaterThanFillInVariableMap.put(2, ExpressionParser.parse("1", null, null));

greaterThanExerciseVariableMap.put("a", ExpressionParser.parse("8", null, null));
greaterThanExerciseVariableMap.put("b", ExpressionParser.parse("25", null, null));
}

@Test
public void testGreaterThan1() {
assertTrue(Evaluator.getBooleanResult("22>8", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThan2() {
assertTrue(!Evaluator.getBooleanResult("2>8", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThan3() {
assertTrue(Evaluator.getBooleanResult("5.7>3.5", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThan4() {
assertTrue(Evaluator.getBooleanResult("1>-1", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThan5() {
assertTrue(Evaluator.getBooleanResult("0.2>0", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithVariables1() {
assertTrue(Evaluator.getBooleanResult("[var=b]>8", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithVariables2() {
assertTrue(!Evaluator.getBooleanResult("[var=a]>9", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithVariables3() {
assertTrue(Evaluator.getBooleanResult("[var=b]>[var=a]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithVariables4() {
assertTrue(!Evaluator.getBooleanResult("[var=a]>[var=b]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithVariables5() {
assertTrue(Evaluator.getBooleanResult("22>[var=a]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithVariables6() {
assertTrue(!Evaluator.getBooleanResult("2>[var=a]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput1() {
assertTrue(Evaluator.getBooleanResult("[pos=1]>2", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput2() {
assertTrue(Evaluator.getBooleanResult("34>[pos=2]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput3() {
assertTrue(!Evaluator.getBooleanResult("[pos=2]>2", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput4() {
assertTrue(Evaluator.getBooleanResult("[pos=1]>[pos=2]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput5() {
assertTrue(!Evaluator.getBooleanResult("[pos=2]>[pos=1]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput6() {
assertTrue(Evaluator.getBooleanResult("22>[pos=1]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput7() {
assertTrue(!Evaluator.getBooleanResult("2>[pos=1]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithEncapsulation1() {
assertTrue(Evaluator.getBooleanResult("1 > (1 > 2)", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithEncapsulation2() {
assertTrue(!Evaluator.getBooleanResult("1 > (1 > (1 > 2))", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithEncapsulation3() {
assertTrue(!Evaluator.getBooleanResult("1 > (1 > (1 > (1 > (1 > 2))))", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithEncapsulation4() {
assertTrue(Evaluator.getBooleanResult("((((1 > 1) > 1) > 1) > 1) > -1", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test(expected=ParserException.class)
public void testGreaterThanWithWrongInputCharacter() {
Evaluator.getBooleanResult("6 > ab", greaterThanExerciseVariableMap, greaterThanFillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidArgumentTypeException.class)
public void testGreaterThanWithWrongInputString() {
Evaluator.getBooleanResult("6 > 'a'", greaterThanExerciseVariableMap, greaterThanFillInVariableMap);
fail();
}

@Test (expected=UndefinedExerciseVariableException.class)
public void testGreaterThanWithMissingExcerciseVariable() {
Evaluator.getBooleanResult("[var=j] > 2", greaterThanExerciseVariableMap, greaterThanFillInVariableMap);
fail();
}

@Test (expected=UndefinedFillInVariableException.class)
public void testGreaterThanWithMissingInput() {
Evaluator.getBooleanResult("[pos=42] > 2", greaterThanExerciseVariableMap, greaterThanFillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===

[[Kategorie:Evaluatorfunktion]]

GreaterThan

2017-09-18T10:54:01Z

Mbuttgereit: /* JUnit Tests */

===Beschreibung===
Die Funktion ''greaterThan'' vergleicht zwei Ausdrücke nach der Größe miteinander.

===Syntax===
a > b

===Parameter===
* '''a''' - double
* '''b''' - double

===Return Value===
* Gibt einen Boolean zurück

===Beispiele===
<math>6 > 3</math>

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() throws FunctionNotImplementedException, UndefinedFillInVariableException,
UndefinedExerciseVariableException, ParserException, ErroneousFillInVariableException, ErroneousExerciseVariableException {
greaterThanFillInVariableMap.put(1, ExpressionParser.parse("3", null, null));
greaterThanFillInVariableMap.put(2, ExpressionParser.parse("1", null, null));

greaterThanExerciseVariableMap.put("a", ExpressionParser.parse("8", null, null));
greaterThanExerciseVariableMap.put("b", ExpressionParser.parse("25", null, null));
}

@Test
public void testGreaterThan1() {
assertTrue(Evaluator.getBooleanResult("22>8", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThan2() {
assertTrue(!Evaluator.getBooleanResult("2>8", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThan3() {
assertTrue(Evaluator.getBooleanResult("5.7>3.5", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThan4() {
assertTrue(Evaluator.getBooleanResult("1>-1", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThan5() {
assertTrue(Evaluator.getBooleanResult("0.2>0", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithVariables1() {
assertTrue(Evaluator.getBooleanResult("[var=b]>8", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithVariables2() {
assertTrue(!Evaluator.getBooleanResult("[var=a]>9", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithVariables3() {
assertTrue(Evaluator.getBooleanResult("[var=b]>[var=a]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithVariables4() {
assertTrue(!Evaluator.getBooleanResult("[var=a]>[var=b]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithVariables5() {
assertTrue(Evaluator.getBooleanResult("22>[var=a]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithVariables6() {
assertTrue(!Evaluator.getBooleanResult("2>[var=a]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput1() {
assertTrue(Evaluator.getBooleanResult("[pos=1]>2", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput2() {
assertTrue(Evaluator.getBooleanResult("34>[pos=2]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput3() {
assertTrue(!Evaluator.getBooleanResult("[pos=2]>2", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput4() {
assertTrue(Evaluator.getBooleanResult("[pos=1]>[pos=2]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput5() {
assertTrue(!Evaluator.getBooleanResult("[pos=2]>[pos=1]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput6() {
assertTrue(Evaluator.getBooleanResult("22>[pos=1]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithInput7() {
assertTrue(!Evaluator.getBooleanResult("2>[pos=1]", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithEncapsulation1() {
assertTrue(Evaluator.getBooleanResult("1 > (1 > 2)", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithEncapsulation2() {
assertTrue(!Evaluator.getBooleanResult("1 > (1 > (1 > 2))", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithEncapsulation3() {
assertTrue(!Evaluator.getBooleanResult("1 > (1 > (1 > (1 > (1 > 2))))", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test
public void testGreaterThanWithEncapsulation4() {
assertTrue(Evaluator.getBooleanResult("((((1 > 1) > 1) > 1) > 1) > -1", greaterThanExerciseVariableMap, greaterThanFillInVariableMap));
}

@Test(expected=ParserException.class)
public void testGreaterThanWithWrongInputCharacter() {
Evaluator.getBooleanResult("6 > ab", greaterThanExerciseVariableMap, greaterThanFillInVariableMap);
fail();
}

@Test(expected=FunctionInvalidArgumentTypeException.class)
public void testGreaterThanWithWrongInputString() {
Evaluator.getBooleanResult("6 > 'a'", greaterThanExerciseVariableMap, greaterThanFillInVariableMap);
fail();
}

@Test (expected=UndefinedExerciseVariableException.class)
public void testGreaterThanWithMissingExcerciseVariable() {
Evaluator.getBooleanResult("[var=j] > 2", greaterThanExerciseVariableMap, greaterThanFillInVariableMap);
fail();
}

@Test (expected=UndefinedFillInVariableException.class)
public void testGreaterThanWithMissingInput() {
Evaluator.getBooleanResult("[pos=42] > 2", greaterThanExerciseVariableMap, greaterThanFillInVariableMap);
fail();
}
</syntaxhighlight>

===Hinweise===

[[Kategorie:Evaluatorfunktion]]

GetNumerator

2017-09-18T10:53:28Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Mit der Funktion ''getNumerator'' erhält man den Zähler eines Bruches. Die Funktion erwartet einen String, bei dem es sich um einen Bruch handeln muss, und gibt eine Zahl zurück.

=== Syntax ===
getNumerator(String bruch)

=== Parameter ===
* '''bruch''' - der Bruch, dessen Zähler bestimmt werden soll

=== Return Value ===
* Gibt eine Ganzzahl zurück

=== Beispiele ===
getNumerator('3/5') --> returns 3

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() throws FunctionNotImplementedException, UndefinedFillInVariableException,
UndefinedExerciseVariableException, ParserException, ErroneousFillInVariableException,
ErroneousExerciseVariableException {
getNumeratorFillInVariableMap.put(1, ExpressionParser.parse("0", null, null));
getNumeratorFillInVariableMap.put(2, ExpressionParser.parse("20/3", null, null));
getNumeratorFillInVariableMap.put(3, ExpressionParser.parse("10.3", null, null));
getNumeratorFillInVariableMap.put(4, ExpressionParser.parse("-5", null, null));
getNumeratorFillInVariableMap.put(5, ExpressionParser.parse("5", null, null));

getNumeratorExerciseVariableMap.put("a", ExpressionParser.parse("0", null, null));
getNumeratorExerciseVariableMap.put("b", ExpressionParser.parse("20/3", null, null));
getNumeratorExerciseVariableMap.put("c", ExpressionParser.parse("10.3", null, null));
getNumeratorExerciseVariableMap.put("d", ExpressionParser.parse("-5", null, null));
getNumeratorExerciseVariableMap.put("e", ExpressionParser.parse("5", null, null));
}

@Test
public void testGetNumerator1() {
assertEquals(3, Evaluator.getNumberResult("getNumerator(3/7)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumerator2() {
assertEquals(10, Evaluator.getNumberResult("getNumerator(10/7)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumerator3() {
assertEquals(20.3, Evaluator.getNumberResult("getNumerator(20.3/-10)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumerator4() {
assertEquals(0, Evaluator.getNumberResult("getNumerator('0/5')", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumerator5() {
assertNotEquals(4, Evaluator.getNumberResult("getNumerator('8/6')", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumerator6() {
assertEquals(-5, Evaluator.getNumberResult("getNumerator(-5/3.2)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test(expected = FunctionInvalidArgumentException.class)
public void testGetNumeratorAtDefinitionZero() {
Evaluator.getNumberResult("getNumerator(3/0)", getNumeratorExerciseVariableMap, getNumeratorFillInVariableMap); // Result
// //
// undefined
}

@Test
public void testGetNumeratorWithInput1() {
assertEquals(20, Evaluator.getNumberResult("getNumerator([pos=2])", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithInput2() {
assertEquals(0, Evaluator.getNumberResult("getNumerator([pos=1]/7)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithInput3() {
assertEquals(10.3, Evaluator.getNumberResult("getNumerator([pos=3]/5)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithInput4() {
assertEquals(-5, Evaluator.getNumberResult("getNumerator([pos=4]/[pos=3])", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithVariables1() {
assertEquals(20, Evaluator.getNumberResult("getNumerator([var=b])", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithVariables2() {
assertEquals(0, Evaluator.getNumberResult("getNumerator([var=a]/7)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithVariables3() {
assertEquals(10.3, Evaluator.getNumberResult("getNumerator([var=c]/5)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithVariables4() {
assertEquals(-5, Evaluator.getNumberResult("getNumerator([var=d]/[var=c])", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithExpressions1() {
assertEquals(5, Evaluator.getNumberResult("getNumerator((2+3)/4)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithExpressions2() {
assertEquals(3, Evaluator.getNumberResult("getNumerator((getNumerator('3/2'))/4)",
getNumeratorExerciseVariableMap, getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithExpressions3() {
assertEquals(5, Evaluator.getNumberResult("getNumerator((getNumerator('[pos=5]/7'))/4)",
getNumeratorExerciseVariableMap, getNumeratorFillInVariableMap), 0.0);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testGetNumeratorWithWrongInputPointNumber() {
Evaluator.getNumberResult("getNumerator(2.2)", getNumeratorExerciseVariableMap, getNumeratorFillInVariableMap);
fail();
}

@Test(expected = ParserException.class)
public void testGetNumeratorWithWrongInputCharacter() {
Evaluator.getNumberResult("getNumerator(ab/2)", getNumeratorExerciseVariableMap, getNumeratorFillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testGetNumeratorWithTwoArguments() {
Evaluator.getNumberResult("getNumerator('7/3', '12/2')", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testGetNumeratorWithThreeArguments() {
Evaluator.getNumberResult("getNumerator('1/1', '3/9', '7/8')", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testGetNumeratorWithMissingExerciseVariable() {
Evaluator.getNumberResult("getNumerator('[var=j]/3')", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testGetNumeratorWithMissingInput() {
Evaluator.getNumberResult("getNumerator('[pos=42]/3')", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===

[[Kategorie:Evaluatorfunktion]]

GetFromSet

2017-09-18T10:24:44Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''getFromSet'' wählt das Element an einer bestimmten Stelle aus einer gegebenen Menge aus. Dabei beginnt die Nummerierung der Elemente mit 0.

Die Funktion erwartet eine Zahl, die Stelle an der das Element aus der Menge genommen wird, und einen String, die Menge selbst. Es wird eine Zahl zurückgegeben.

=== Syntax ===
getFromSet(int stelle, String menge)

=== Parameter ===
* '''stelle''' - an der wievielten Stelle aus der geordneten Menge gezogen werden soll
* '''menge''' - die Menge, aus der gezogen wird

=== Return Value ===
* Gibt einen String zurück

=== Beispiele ===
==== Standardfälle ====
getFromSet('1','{1;2;3}') --> returns 2
getFromSet('2','{a;b;c}') --> returns c

==== Benutzung von Variablen ====
getFromSet('[pos=1]','{1;2;3}')
getFromSet('1','{1;2;[var=a]}')
getFromSet('[var=b]','{1;2;[pos=1]}')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
OMOBJ zero = new OMOBJ();
OMOBJ two = new OMOBJ();
OMOBJ mtwo = new OMOBJ();
OMOBJ e = new OMOBJ();
e.setOMV(OMCreator.createOMV("e"));
zero.setOMI(OMCreator.createOMI(0));
two.setOMI(OMCreator.createOMI(2));
mtwo.setOMI(OMCreator.createOMI(-2));

fillIn.put(1, zero);
fillIn.put(2, two);
fillIn.put(3, mtwo);
fillIn.put(4, e);

exerVar.put("a", zero);
exerVar.put("b", two);
exerVar.put("c", mtwo);
exerVar.put("d", e);
}

@Test
public void testGetFromSet1() {
assertEquals(2, Evaluator.getNumberResult("getFromSet('1', '{1;2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSet2() {
assertEquals(true, Evaluator.getBooleanResult("'c' == getFromSet('2', '{a;b;c}')", exerVar, fillIn));
}

@Test
public void testGetFromSet3() {
assertEquals(42, Evaluator.getNumberResult("getFromSet('3', {a;12;'lalilu';42;-1})", exerVar, fillIn), 0);
}

@Test
public void testGetFromSet4() {
assertEquals(true, Evaluator.getBooleanResult(" '}' ==getFromSet('1', {2;'}';3})", exerVar, fillIn));
}

@Test
public void testGetFromSet5() {
assertEquals(3, Evaluator.getNumberResult("getFromSet('2', {2;'}';3})", exerVar, fillIn), 0);
}

@Test
public void testGetFromSet6() {
assertEquals(2, Evaluator.getNumberResult("getFromSet('1', '{1;2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSet7() {
assertEquals(true, Evaluator.getBooleanResult("'c' == getFromSet('2', '{a;b;c}')", exerVar, fillIn));
}

@Test
public void testGetFromSet8() {
assertEquals(42, Evaluator.getNumberResult("getFromSet('3', {a;12;'lalilu';42;-1})", exerVar, fillIn), 0);
}

@Test
public void testGetFromSet9() {
OMOBJ expected = new OMOBJ();
expected.setOMSTR(OMCreator.createOMSTR("1,3,2,7"));
assertEquals(expected, (Evaluator.evaluate("getFromSet('0', {'1,3,2,7'})", exerVar, fillIn)));
}

@Test
public void testGetFromSetWithInput1() {
assertEquals(0, Evaluator.getNumberResult("getFromSet('0', '{[pos=1];2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithInput2() {
assertEquals(-2, Evaluator.getNumberResult("getFromSet('[pos=1]', '{[pos=3];2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithInput3() {
assertEquals(true,
Evaluator.getBooleanResult("'e' == getFromSet('[pos=2]', '{a;b;[pos=4]}')", exerVar, fillIn));
}

@Test
public void testGetFromSetWithVariables1() {
assertEquals(0, Evaluator.getNumberResult("getFromSet('0', '{[var=a];2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithVariables2() {
assertEquals(-2, Evaluator.getNumberResult("getFromSet('[var=a]', '{[var=c];2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithVariables3() {
assertEquals(true,
Evaluator.getBooleanResult("'e' == getFromSet('[var=b]', '{a;b;[var=d]}')", exerVar, fillIn));
}

@Test
public void testGetFromSetWithPointNumber1() {
assertEquals(3.2, Evaluator.getNumberResult("getFromSet('0', '{3.2;2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithPointNumber2() {
assertEquals(-2.2, Evaluator.getNumberResult("getFromSet('[var=a]', '{-2.2;2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithPointNumber3() {
assertEquals(true, Evaluator.getBooleanResult("'e.a' == getFromSet('2', {a;b;'e.a'})", exerVar, fillIn));
}

@Test
public void testGetFromSetWithOneRationalAndOneTextArgument() {
assertEquals(4, Evaluator.getNumberResult("getFromSet('1', '{2;4;5}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithTwoTextArguments() {
assertEquals(4, Evaluator.getNumberResult("getFromSet('1', '{2;4;5}')", exerVar, fillIn), 0);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testGetFromSetWithOneArgument() {
Evaluator.getNumberResult("getFromSet('3')", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testGetFromSetWithThreeArguments() {
Evaluator.getNumberResult("getFromSet('4', '{3;1;-7}', '{12;-12}')", exerVar, fillIn);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testGetFromSetWithMissingInput() {
Evaluator.getNumberResult("getFromSet('2', '{[pos=42];4;5}')", exerVar, fillIn);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testGetFromSetWithMissingExerciseVariable() {
Evaluator.getNumberResult("getFromSet('2', '{[var=j];4;5}')", exerVar, fillIn);
}
</syntaxhighlight>

=== Hinweise ===
* Mengen werden mit geschweiften Klammern beschrieben, die Elemente sind mit Semikolons zu trennen.

[[Kategorie:Evaluatorfunktion]]

GetFromSet

2017-09-18T10:24:09Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''getFromSet'' wählt das Element an einer bestimmten Stelle aus einer gegebenen Menge aus. Dabei beginnt die Nummerierung der Elemente mit 0.

Die Funktion erwartet eine Zahl, die Stelle an der das Element aus der Menge genommen wird, und einen String, die Menge selbst. Es wird eine Zahl zurückgegeben.

=== Syntax ===
getFromSet(int stelle, String menge)

=== Parameter ===
* '''stelle''' - an der wievielten Stelle aus der geordneten Menge gezogen werden soll
* '''menge''' - die Menge, aus der gezogen wird

=== Return Value ===
* Gibt einen String zurück

=== Beispiele ===
==== Standardfälle ====
getFromSet('1','{1;2;3}') --> returns 2
getFromSet('2','{a;b;c}') --> returns c

==== Benutzung von Variablen ====
getFromSet('[pos=1]','{1;2;3}')
getFromSet('1','{1;2;[var=a]}')
getFromSet('[var=b]','{1;2;[pos=1]}')

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() throws FunctionNotImplementedException, UndefinedFillInVariableException,
UndefinedExerciseVariableException, ParserException, ErroneousFillInVariableException,
ErroneousExerciseVariableException {
getNumeratorFillInVariableMap.put(1, ExpressionParser.parse("0", null, null));
getNumeratorFillInVariableMap.put(2, ExpressionParser.parse("20/3", null, null));
getNumeratorFillInVariableMap.put(3, ExpressionParser.parse("10.3", null, null));
getNumeratorFillInVariableMap.put(4, ExpressionParser.parse("-5", null, null));
getNumeratorFillInVariableMap.put(5, ExpressionParser.parse("5", null, null));

getNumeratorExerciseVariableMap.put("a", ExpressionParser.parse("0", null, null));
getNumeratorExerciseVariableMap.put("b", ExpressionParser.parse("20/3", null, null));
getNumeratorExerciseVariableMap.put("c", ExpressionParser.parse("10.3", null, null));
getNumeratorExerciseVariableMap.put("d", ExpressionParser.parse("-5", null, null));
getNumeratorExerciseVariableMap.put("e", ExpressionParser.parse("5", null, null));
}

@Test
public void testGetNumerator1() {
assertEquals(3, Evaluator.getNumberResult("getNumerator(3/7)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumerator2() {
assertEquals(10, Evaluator.getNumberResult("getNumerator(10/7)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumerator3() {
assertEquals(20.3, Evaluator.getNumberResult("getNumerator(20.3/-10)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumerator4() {
assertEquals(0, Evaluator.getNumberResult("getNumerator('0/5')", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumerator5() {
assertNotEquals(4, Evaluator.getNumberResult("getNumerator('8/6')", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumerator6() {
assertEquals(-5, Evaluator.getNumberResult("getNumerator(-5/3.2)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test(expected = FunctionInvalidArgumentException.class)
public void testGetNumeratorAtDefinitionZero() {
Evaluator.getNumberResult("getNumerator(3/0)", getNumeratorExerciseVariableMap, getNumeratorFillInVariableMap); // Result
// //
// undefined
}

@Test
public void testGetNumeratorWithInput1() {
assertEquals(20, Evaluator.getNumberResult("getNumerator([pos=2])", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithInput2() {
assertEquals(0, Evaluator.getNumberResult("getNumerator([pos=1]/7)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithInput3() {
assertEquals(10.3, Evaluator.getNumberResult("getNumerator([pos=3]/5)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithInput4() {
assertEquals(-5, Evaluator.getNumberResult("getNumerator([pos=4]/[pos=3])", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithVariables1() {
assertEquals(20, Evaluator.getNumberResult("getNumerator([var=b])", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithVariables2() {
assertEquals(0, Evaluator.getNumberResult("getNumerator([var=a]/7)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithVariables3() {
assertEquals(10.3, Evaluator.getNumberResult("getNumerator([var=c]/5)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithVariables4() {
assertEquals(-5, Evaluator.getNumberResult("getNumerator([var=d]/[var=c])", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithExpressions1() {
assertEquals(5, Evaluator.getNumberResult("getNumerator((2+3)/4)", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithExpressions2() {
assertEquals(3, Evaluator.getNumberResult("getNumerator((getNumerator('3/2'))/4)",
getNumeratorExerciseVariableMap, getNumeratorFillInVariableMap), 0.0);
}

@Test
public void testGetNumeratorWithExpressions3() {
assertEquals(5, Evaluator.getNumberResult("getNumerator((getNumerator('[pos=5]/7'))/4)",
getNumeratorExerciseVariableMap, getNumeratorFillInVariableMap), 0.0);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testGetNumeratorWithWrongInputPointNumber() {
Evaluator.getNumberResult("getNumerator(2.2)", getNumeratorExerciseVariableMap, getNumeratorFillInVariableMap);
fail();
}

@Test(expected = ParserException.class)
public void testGetNumeratorWithWrongInputCharacter() {
Evaluator.getNumberResult("getNumerator(ab/2)", getNumeratorExerciseVariableMap, getNumeratorFillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testGetNumeratorWithTwoArguments() {
Evaluator.getNumberResult("getNumerator('7/3', '12/2')", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap);
fail();
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testGetNumeratorWithThreeArguments() {
Evaluator.getNumberResult("getNumerator('1/1', '3/9', '7/8')", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap);
fail();
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testGetNumeratorWithMissingExerciseVariable() {
Evaluator.getNumberResult("getNumerator('[var=j]/3')", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap);
fail();
}

@Test(expected = UndefinedFillInVariableException.class)
public void testGetNumeratorWithMissingInput() {
Evaluator.getNumberResult("getNumerator('[pos=42]/3')", getNumeratorExerciseVariableMap,
getNumeratorFillInVariableMap);
fail();
}
</syntaxhighlight>

=== Hinweise ===
* Mengen werden mit geschweiften Klammern beschrieben, die Elemente sind mit Semikolons zu trennen.

[[Kategorie:Evaluatorfunktion]]

GetFromOrderedSet

2017-09-18T10:23:46Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''getFromOrderedSet'' wählt das Element an einer bestimmten Stelle aus einer vorher sortierten Zahlenmenge aus. Dabei beginnt die Nummerierung der geordneten Elemente mit 0.

Die Funktion erwartet eine Zahl, die Stelle an der das Element aus der Menge genommen wird, und einen String, die Menge selbst. Es wird eine Zahl zurückgegeben.

=== Syntax ===
getFromOrderedSet(int stelle, String menge)

=== Parameter ===
* '''stelle''' - an der wievielten Stelle aus der geordneten Menge gezogen werden soll
* '''menge''' - die Menge, aus der gezogen wird

=== Return Value ===
* Gibt eine Zahl zurück

=== Beispiele ===
getFromOrderedSet('3','{1;2;3;4}') --> returns 4
getFromOrderedSet('3','{3;2;4;1}') --> returns 4

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
OMOBJ zero = new OMOBJ();
OMOBJ mfour = new OMOBJ();
OMOBJ twenty = new OMOBJ();
zero.setOMI(OMCreator.createOMI(0));
mfour.setOMI(OMCreator.createOMI(-4));
twenty.setOMI(OMCreator.createOMI(20));

fillIn.put(1, zero);
fillIn.put(2, mfour);
fillIn.put(3, twenty);

exerVar.put("a", zero);
exerVar.put("b", mfour);
exerVar.put("c", twenty);
}

@Test
public void testGetFromOrderedSet1() {
assertTrue(3 == Evaluator.getNumberResult("getFromOrderedSet('1', '{2;3;5;6}')", exerVar, fillIn));
}

@Test
public void testGetFromOrderedSet2() {
assertTrue(-2.6 == Evaluator.getNumberResult("getFromOrderedSet('0', '{3;5;6;-2.6}')", exerVar, fillIn));
}

@Test
public void testGetFromOrderedSet3() {
assertTrue(0 == Evaluator.getNumberResult("getFromOrderedSet('1', '{-2.6;3;5;0}')", exerVar, fillIn));
}

@Test
public void testGetFromOrderedSet4() {
assertTrue(5 == Evaluator.getNumberResult("getFromOrderedSet('3', '{-2.6;3;5;0}')", exerVar, fillIn));
}

@Test
public void testGetFromOrderedSet5() {
assertTrue(1 == Evaluator.getNumberResult("getFromOrderedSet('0', '{1;1;1;1}')", exerVar, fillIn));
}

@Test
public void testGetFromOrderedSet6() {
assertTrue(1 == Evaluator.getNumberResult("getFromOrderedSet('3', '{1;1;1;1}')", exerVar, fillIn));
}

@Test
public void testGetFromOrderedSetWithInput1() {
assertTrue(20 == Evaluator.getNumberResult("getFromOrderedSet('2', '{[pos=3];4;5}')", exerVar, fillIn));
}

@Test
public void testGetFromOrderedSetWithInput2() {
assertTrue(-4 == Evaluator.getNumberResult("getFromOrderedSet('0', '{[pos=3];4;5;[pos=2]}')", exerVar, fillIn));
}

@Test
public void testGetFromOrderedSetWithInput3() {
assertTrue(-4 == Evaluator.getNumberResult("getFromOrderedSet('[pos=1]', '{[pos=3];4;5;[pos=2]}')", exerVar,
fillIn));
}

@Test
public void testGetFromOrderedSetWithVariables1() {
assertTrue(20 == Evaluator.getNumberResult("getFromOrderedSet('2', '{[var=c];4;5}')", exerVar, fillIn));
}

@Test
public void testGetFromOrderedSetWithVariables2() {
assertTrue(-4 == Evaluator.getNumberResult("getFromOrderedSet('0', '{[var=c];4;5;[var=b]}')", exerVar, fillIn));
}

@Test
public void testGetFromOrderedSetWithVariables3() {
assertTrue(-4 == Evaluator.getNumberResult("getFromOrderedSet('[var=a]', '{[var=c];4;5;[var=b]}')", exerVar,
fillIn));
}

@Test
public void testGetFromOrderedSetWithOneRationalAndOneTextArgument() {
assertTrue(4 == Evaluator.getNumberResult("getFromOrderedSet('1', '{2;4;5}')", exerVar, fillIn));
}

@Test
public void testGetFromOrderedSetWithTwoTextArguments() {
assertTrue(4 == Evaluator.getNumberResult("getFromOrderedSet('1', '{2;4;5}')", exerVar, fillIn));
}

@Test // (expected=FunctionInvalidArgumentTypeException.class) Now works, single chars
// are recognized as Variables
public void testGetFromOrderedSetWithWrongInputCharacters() {
assertEquals(OMCreator.createOMOBJ(OMCreator.createOMSTR("b")),
Evaluator.evaluate("getFromOrderedSet('1', '{a;b;c;d}')", exerVar, fillIn));
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testGetFromOrderedSetWithWrongInputCharacterIndex() {
Evaluator.getNumberResult("getFromOrderedSet('a', '{1;2;3;4}')", exerVar, fillIn);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testGetFromOrderedSetWithWrongInputDoubleIndex() {
Evaluator.getNumberResult("getFromOrderedSet('5.5', '{1;2;3;4}')", exerVar, fillIn);
}

@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testGetFromOrderedSetWithWrongInputComma() {
Evaluator.getNumberResult("getFromOrderedSet('3', '{1,5,3,7}')", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testGetFromOrderedSetWithOneArgument() {
Evaluator.getNumberResult("getFromOrderedSet('7')", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testGetFromOrderedSetWithThreeArguments() {
Evaluator.getNumberResult("getFromOrderedSet('4', '{3;1;-1}', '{12;-3}')", exerVar, fillIn);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testGetFromOrderedSetWithMissingInput() {
Evaluator.getNumberResult("getFromOrderedSet('2', '{[pos=42];4;5}')", exerVar, fillIn);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testGetFromOrderedSetWithMissingExerciseVariable() {
Evaluator.getNumberResult("getFromOrderedSet('2', '{[var=j];4;5}')", exerVar, fillIn);
}
</syntaxhighlight>

=== Hinweise ===
* Egal in welcher Reihenfolge die Elemente in der Menge stehen, die Funktion ordnet sie zunächst der Größe nach und gibt dann das Element an der entsprechenden Stelle zurück.
* Mengen werden mit geschweiften Klammern beschrieben, die Elemente sind mit Semikolons zu trennen.

[[Kategorie:Evaluatorfunktion]]

GetFromOrderedSet

2017-09-18T10:23:16Z

Mbuttgereit: /* JUnit Tests */

=== Beschreibung ===
Die Funktion ''getFromOrderedSet'' wählt das Element an einer bestimmten Stelle aus einer vorher sortierten Zahlenmenge aus. Dabei beginnt die Nummerierung der geordneten Elemente mit 0.

Die Funktion erwartet eine Zahl, die Stelle an der das Element aus der Menge genommen wird, und einen String, die Menge selbst. Es wird eine Zahl zurückgegeben.

=== Syntax ===
getFromOrderedSet(int stelle, String menge)

=== Parameter ===
* '''stelle''' - an der wievielten Stelle aus der geordneten Menge gezogen werden soll
* '''menge''' - die Menge, aus der gezogen wird

=== Return Value ===
* Gibt eine Zahl zurück

=== Beispiele ===
getFromOrderedSet('3','{1;2;3;4}') --> returns 4
getFromOrderedSet('3','{3;2;4;1}') --> returns 4

====JUnit Tests====
[Anzeigen]
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
OMOBJ zero = new OMOBJ();
OMOBJ two = new OMOBJ();
OMOBJ mtwo = new OMOBJ();
OMOBJ e = new OMOBJ();
e.setOMV(OMCreator.createOMV("e"));
zero.setOMI(OMCreator.createOMI(0));
two.setOMI(OMCreator.createOMI(2));
mtwo.setOMI(OMCreator.createOMI(-2));

fillIn.put(1, zero);
fillIn.put(2, two);
fillIn.put(3, mtwo);
fillIn.put(4, e);

exerVar.put("a", zero);
exerVar.put("b", two);
exerVar.put("c", mtwo);
exerVar.put("d", e);
}

@Test
public void testGetFromSet1() {
assertEquals(2, Evaluator.getNumberResult("getFromSet('1', '{1;2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSet2() {
assertEquals(true, Evaluator.getBooleanResult("'c' == getFromSet('2', '{a;b;c}')", exerVar, fillIn));
}

@Test
public void testGetFromSet3() {
assertEquals(42, Evaluator.getNumberResult("getFromSet('3', {a;12;'lalilu';42;-1})", exerVar, fillIn), 0);
}

@Test
public void testGetFromSet4() {
assertEquals(true, Evaluator.getBooleanResult(" '}' ==getFromSet('1', {2;'}';3})", exerVar, fillIn));
}

@Test
public void testGetFromSet5() {
assertEquals(3, Evaluator.getNumberResult("getFromSet('2', {2;'}';3})", exerVar, fillIn), 0);
}

@Test
public void testGetFromSet6() {
assertEquals(2, Evaluator.getNumberResult("getFromSet('1', '{1;2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSet7() {
assertEquals(true, Evaluator.getBooleanResult("'c' == getFromSet('2', '{a;b;c}')", exerVar, fillIn));
}

@Test
public void testGetFromSet8() {
assertEquals(42, Evaluator.getNumberResult("getFromSet('3', {a;12;'lalilu';42;-1})", exerVar, fillIn), 0);
}

@Test
public void testGetFromSet9() {
OMOBJ expected = new OMOBJ();
expected.setOMSTR(OMCreator.createOMSTR("1,3,2,7"));
assertEquals(expected, (Evaluator.evaluate("getFromSet('0', {'1,3,2,7'})", exerVar, fillIn)));
}

@Test
public void testGetFromSetWithInput1() {
assertEquals(0, Evaluator.getNumberResult("getFromSet('0', '{[pos=1];2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithInput2() {
assertEquals(-2, Evaluator.getNumberResult("getFromSet('[pos=1]', '{[pos=3];2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithInput3() {
assertEquals(true,
Evaluator.getBooleanResult("'e' == getFromSet('[pos=2]', '{a;b;[pos=4]}')", exerVar, fillIn));
}

@Test
public void testGetFromSetWithVariables1() {
assertEquals(0, Evaluator.getNumberResult("getFromSet('0', '{[var=a];2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithVariables2() {
assertEquals(-2, Evaluator.getNumberResult("getFromSet('[var=a]', '{[var=c];2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithVariables3() {
assertEquals(true,
Evaluator.getBooleanResult("'e' == getFromSet('[var=b]', '{a;b;[var=d]}')", exerVar, fillIn));
}

@Test
public void testGetFromSetWithPointNumber1() {
assertEquals(3.2, Evaluator.getNumberResult("getFromSet('0', '{3.2;2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithPointNumber2() {
assertEquals(-2.2, Evaluator.getNumberResult("getFromSet('[var=a]', '{-2.2;2;3}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithPointNumber3() {
assertEquals(true, Evaluator.getBooleanResult("'e.a' == getFromSet('2', {a;b;'e.a'})", exerVar, fillIn));
}

@Test
public void testGetFromSetWithOneRationalAndOneTextArgument() {
assertEquals(4, Evaluator.getNumberResult("getFromSet('1', '{2;4;5}')", exerVar, fillIn), 0);
}

@Test
public void testGetFromSetWithTwoTextArguments() {
assertEquals(4, Evaluator.getNumberResult("getFromSet('1', '{2;4;5}')", exerVar, fillIn), 0);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testGetFromSetWithOneArgument() {
Evaluator.getNumberResult("getFromSet('3')", exerVar, fillIn);
}

@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testGetFromSetWithThreeArguments() {
Evaluator.getNumberResult("getFromSet('4', '{3;1;-7}', '{12;-12}')", exerVar, fillIn);
}

@Test(expected = UndefinedFillInVariableException.class)
public void testGetFromSetWithMissingInput() {
Evaluator.getNumberResult("getFromSet('2', '{[pos=42];4;5}')", exerVar, fillIn);
}

@Test(expected = UndefinedExerciseVariableException.class)
public void testGetFromSetWithMissingExerciseVariable() {
Evaluator.getNumberResult("getFromSet('2', '{[var=j];4;5}')", exerVar, fillIn);
}
</syntaxhighlight>

=== Hinweise ===
* Egal in welcher Reihenfolge die Elemente in der Menge stehen, die Funktion ordnet sie zunächst der Größe nach und gibt dann das Element an der entsprechenden Stelle zurück.
* Mengen werden mit geschweiften Klammern beschrieben, die Elemente sind mit Semikolons zu trennen.

[[Kategorie:Evaluatorfunktion]]