BooleanAnd: Unterschied zwischen den Versionen

Aus JACK Wiki
Zur Navigation springen Zur Suche springen
 
(32 dazwischenliegende Versionen von 7 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
===Zugehörige Evaluatoren===
*'''ChemEvaluator'''
*'''MathEvaluator'''
===Beschreibung===
===Beschreibung===
Die Funktion ''BooleanAnd'' ("&&") aus der Bool'schen Algebra vergleicht zwei Aussagen auf "true" oder "false". Der Ausdruck x && y gibt true zurück, wenn x und y beide true sind, ansonsten wird immer false zurückgegeben.
Die Funktion ''BooleanAnd'' ("&&") aus der Bool'schen Algebra vergleicht zwei Aussagen auf "true" oder "false". Der Ausdruck x && y gibt true zurück, wenn x und y beide true sind, ansonsten wird immer false zurückgegeben.
Achtung: In XML Dateien muss das Zeichen & durch &''amp''; ersetz werden!


===Syntax===
===Syntax===
x && y
  x && y
  and(x,y)


===Parameter===
===Parameter===
* '''x''' - boolean
* '''x''' - [[Boolean]]
* '''y''' - boolean
* '''y''' - [[Boolean]]


===Return Value===
===Return Value===
Zeile 13: Zeile 20:


===Beispiele===
===Beispiele===
  1 && 1    --> true
==== Standardfälle ====
  0 && 1    --> false
1 && 1    --> returns ''true''
  1 && 0    --> false
  0 && 0    --> false
0 && 1    --> returns ''false''
 
  (2+4==6) && (3+3==6)    --> true
1 && 0    --> returns ''false''
 
====JUnit Tests====
0 && 0    --> returns ''false''
@Test
public void testBooleanAnd1() {
(2+4==6) && (3+3==6)    --> returns ''true''
assertTrue(Evaluator.getBooleanResult("1 && 1", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAnd2() {
assertTrue(!Evaluator.getBooleanResult("0 && 1", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAnd3() {
assertTrue(!Evaluator.getBooleanResult("1 && 0", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAnd4() {
assertTrue(!Evaluator.getBooleanResult("0 && 0", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAnd5() {
assertEquals(true, Evaluator.getBooleanResult("(2+4==6) && (3+3==6)", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAndWithVariables1() {
assertTrue(Evaluator.getBooleanResult("[pos=2] && 1", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAndWithVariables2() {
assertFalse(Evaluator.getBooleanResult("0 && [pos=2]", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAndWithInput1() {
assertTrue(Evaluator.getBooleanResult("[var=b] && 1", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAndWithInput2() {
assertFalse(Evaluator.getBooleanResult("0 && [var=a]", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAndWithEncapsulation1() {
assertFalse(Evaluator.getBooleanResult("1 && (1 && 0)", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAndWithEncapsulation2() {
assertTrue(Evaluator.getBooleanResult("1 && (1 && 1)", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAndWithEncapsulation3() {
assertFalse(Evaluator.getBooleanResult("1 && (1 && (1 && (1 &&(1 && 0))))", exerciseVariableMap,
fillInVariableMap));
}
 
@Test
public void testBooleanAndWithEncapsulation4() {
assertTrue(Evaluator.getBooleanResult("1 && (1 && (1 && (1 && (1 && 1))))", exerciseVariableMap,
fillInVariableMap));
}
 
@Test
public void testBooleanAndWithEncapsulation5() {
assertFalse(Evaluator.getBooleanResult("((((0 && 1) && 1) && 1) && 1) && 1", exerciseVariableMap,
fillInVariableMap));
}
 
@Test
public void testBooleanAndWithEncapsulation6() {
assertTrue(Evaluator.getBooleanResult("((((1 && 1) && 1) && 1) && 1) && 1", exerciseVariableMap,
fillInVariableMap));
}
 
@Test
public void testBooleanAndWithDifferentNumbers1() {
assertTrue(Evaluator.getBooleanResult("2 && 2", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAndWithDifferentNumbers2() {
assertFalse(Evaluator.getBooleanResult("-1 && 2", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAndWithDifferentNumbers3() {
assertFalse(Evaluator.getBooleanResult("-1 && 0", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testBooleanAndWithDifferentNumbers4() {
assertTrue(Evaluator.getBooleanResult("2.34 && 1.11", exerciseVariableMap, fillInVariableMap));
}
 
@Test(expected = ParserException.class)
public void testBooleanAndWithWrongInputCharacter() {
Evaluator.getBooleanResult("1 && ab", exerciseVariableMap, fillInVariableMap);
fail();
}
 
@Test(expected = FunctionInvalidArgumentTypeException.class)
public void testBooleanAndWithWrongInputString() {
Evaluator.getBooleanResult("1 && 'a'", exerciseVariableMap, fillInVariableMap);
fail();
}


@Test(expected = UndefinedExerciseVariableException.class)
==== Benutzung mit Variablen ====
public void testBooleanAndMissingExcerciseVariable() {
Evaluator.getBooleanResult("[var=j] && 1", exerciseVariableMap, fillInVariableMap);
fail();
}


@Test(expected = UndefinedFillInVariableException.class)
[var=a] && [var=b]
public void testBooleanAndWithMissingInput() {
Evaluator.getBooleanResult("[pos=42] && 1", exerciseVariableMap, fillInVariableMap);
fail();
}
</syntaxhighlight>


===Hinweise===
===Hinweise===
* erwartet zwei boolsche Ausdrücke
* Es werden zwei boolsche Ausdrücke erwartet.
* Diese Funktion ist ein binärer Operator.


[[Kategorie:Evaluatorfunktion]]
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Chem-Evaluatorfunktion]][[Kategorie:Testfunktionen]][[Category:Operator]][[Kategorie:Booleanfunktionen]][[Kategorie:JACK2]][[Kategorie:JACK3]]

Aktuelle Version vom 18. April 2024, 10:24 Uhr

Zugehörige Evaluatoren

  • ChemEvaluator
  • MathEvaluator

Beschreibung

Die Funktion BooleanAnd ("&&") aus der Bool'schen Algebra vergleicht zwei Aussagen auf "true" oder "false". Der Ausdruck x && y gibt true zurück, wenn x und y beide true sind, ansonsten wird immer false zurückgegeben.

Achtung: In XML Dateien muss das Zeichen & durch &amp; ersetz werden!

Syntax

 x && y
 and(x,y)

Parameter

Return Value

  • Gibt einen Boolean zurück.

Beispiele

Standardfälle

1 && 1    --> returns true

0 && 1    --> returns false

1 && 0    --> returns false

0 && 0    --> returns false

(2+4==6) && (3+3==6)    --> returns true

Benutzung mit Variablen

[var=a] && [var=b]

Hinweise

  • Es werden zwei boolsche Ausdrücke erwartet.
  • Diese Funktion ist ein binärer Operator.
Abgerufen von „https://wiki.uni-due.de/jack/index.php?title=BooleanAnd&oldid=10708“