CompareTo: Unterschied zwischen den Versionen

Aus JACK Wiki
Zur Navigation springen Zur Suche springen
KKeine Bearbeitungszusammenfassung
 
(7 dazwischenliegende Versionen von 4 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
===Zugehörige Evaluatoren===
*'''MathEvaluator'''
=== Beschreibung ===
=== Beschreibung ===
Die Funktion ''compareTo'' bestimmt wie sehr zwei Zeichenketten lexikografisch voneinander abweichen. Die Funktion erwartet zwei Strings und gibt eine Zahl zurück.
Die Funktion ''compareTo'' bestimmt wie sehr zwei Zeichenketten lexikografisch voneinander abweichen. Die Funktion erwartet zwei Strings und gibt eine Zahl zurück.


=== Syntax ===
=== Syntax ===
  compareTo([[Zeichenkette]] text1, [[Zeichenkette]] text2)
  compareTo([[Zeichenkette]] zeichenkette1, [[Zeichenkette]] zeichenkette2)


=== Parameter ===
=== Parameter ===
Zeile 13: Zeile 16:


=== Beispiele ===
=== Beispiele ===
==== Standardfälle ====
  compareTo('hallo','hallo')  --> returns 0
  compareTo('hallo','hallo')  --> returns 0
  compareTo('hallo','JACK')  --> returns 30
  compareTo('hallo','JACK')  --> returns 30
  compareTo('JACK','jack')  --> returns -32
  compareTo('JACK','jack')  --> returns -32


====JUnit Tests====
==== Benutzung mit Variablen ====
<span class="mw-customtoggle-myDivision">[Anzeigen]</span>
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
compareToFillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMSTR>test</OMSTR></OMOBJ>"));
 
compareToExerciseVariableMap.put("a", OMConverter.toObject("<OMOBJ><OMSTR>test</OMSTR></OMOBJ>"));
}
 
@Test
public void testCompareTo1() {
assertEquals(0, Evaluator.getNumberResult("compareTo('Hallo','Hallo')", compareToExerciseVariableMap,
compareToFillInVariableMap), 0.0);
}
 
@Test
public void testCompareTo2() {
assertEquals(0, Evaluator.getNumberResult("compareTo('HAlLo','HAlLo')", compareToExerciseVariableMap,
compareToFillInVariableMap), 0.0);
}
 
@Test
public void testCompareTo3() {
assertTrue(0 < Evaluator.getNumberResult("compareTo('jack','JACK')", compareToExerciseVariableMap,
compareToFillInVariableMap));
}
 
@Test
public void testCompareTo4() {
assertTrue(0 < Evaluator.getNumberResult("compareTo('paluno','JACK')", compareToExerciseVariableMap,
compareToFillInVariableMap));
}
 
@Test
public void testCompareTo5() {
assertTrue(0 > Evaluator.getNumberResult("compareTo('JACK','paluno')", compareToExerciseVariableMap,
compareToFillInVariableMap));
}
 
@Test
public void testCompareTo6() {
assertNotEquals(0, Evaluator.getNumberResult("compareTo('2*x+2*y','2*(x+y)')", compareToExerciseVariableMap,
compareToFillInVariableMap), 0.0);
}
 
@Test
public void testCompareToWithInput() {
assertEquals(0, Evaluator.getNumberResult("compareTo('[pos=1]','test')", compareToExerciseVariableMap,
compareToFillInVariableMap), 0.0);
}
 
@Test
public void testCompareToWithVariables() {
assertEquals(0, Evaluator.getNumberResult("compareTo('[var=a]','test')", compareToExerciseVariableMap,
compareToFillInVariableMap), 0.0);
}
 
@Test(expected = ParserException.class)
public void testCompareToWithWrongInputCharacter() {
Evaluator.evaluate("compareTo(ab,'test')", compareToExerciseVariableMap, compareToFillInVariableMap);
fail();
}
 
@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testCompareToWithOneArgument() {
Evaluator.evaluate("compareTo('Hallo')", compareToExerciseVariableMap, compareToFillInVariableMap);
fail();
}
 
@Test
public void testCompareToWithOneRationalAndOneTextArgument() {
assertNotEquals(Evaluator.getNumberResult("compareTo(12, 'rational')", compareToExerciseVariableMap, compareToFillInVariableMap),0.0);
}


@Test
compareTo([var=a], [var=b])
public void testCompareToWithTwoRationalArguments() {
compareTo([var=a], 'JACK')
assertNotEquals(0, Evaluator.getNumberResult("compareTo(1, 2)", compareToExerciseVariableMap, compareToFillInVariableMap),0.0);
compareTo('hallo', [var=b])
}


@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
==== Benutzung mit studentischen Eingaben ====
public void testCompareToWithThreeArguments() {
Evaluator.evaluate("compareTo('hallo', 'hello', 'hillo')", compareToExerciseVariableMap,
compareToFillInVariableMap);
fail();
}


@Test(expected = UndefinedExerciseVariableException.class)
'''Jack2:'''
public void testCompareToWithMissingExcerciseVariable() {
compareTo([pos=1], [pos=2])
Evaluator.evaluate("compareTo('[var=j]', 'test')", compareToExerciseVariableMap, compareToFillInVariableMap);
compareTo([pos=1], 'JACK')
fail();
compareTo('hallo', [pos=2])
}


@Test(expected = UndefinedFillInVariableException.class)
'''Jack3:'''
public void testCompareToWithMissingInput() {
compareTo([input=field1], [input=field2])
Evaluator.evaluate("compareTo('[pos=42]', 'test')", compareToExerciseVariableMap, compareToFillInVariableMap);
compareTo([input=field1], 'JACK')
fail();
compareTo('hallo', [input=field2])
}
</syntaxhighlight>
compareTo([var=a], [input=field1])
compareTo([input=field1], [var=b])


=== Hinweise ===
=== Hinweise ===
* Die Funktion unterscheidet zwischen Groß- und Kleinschreibung.
* Die Funktion unterscheidet zwischen Groß- und Kleinschreibung.
* Steht der erste String lexikografisch vor dem zweiten String, ist die Rückgabe negativ. Umgekehrt ist die Rückgabe entsprechend positiv.
* Steht der erste String lexikografisch vor dem zweiten String, ist die Rückgabe negativ. Umgekehrt ist die Rückgabe entsprechend positiv.
* Bei der Funktion [[compareToIgnoreCase]] wird zwischen Groß- und Kleinschreibung nicht unterschieden.
* Wenn Variablen genutzt werden muss darauf geachtet werden, dass diese die Voraussetzung erfüllen.
* Wenn die Eingabe der Studierenden genutzt wird muss auch hier darauf geachtet werden, dass die Voraussetzungen erfüllt sind und ob diese an der Stelle genutzt werden können.


[[Kategorie:Evaluatorfunktion]][[Kategorie:Zeichenkettenfunktionen]]
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Zeichenkettenfunktionen]][[Kategorie:JACK2]][[Kategorie:JACK3]]

Aktuelle Version vom 15. April 2024, 12:32 Uhr

Zugehörige Evaluatoren

  • MathEvaluator

Beschreibung

Die Funktion compareTo bestimmt wie sehr zwei Zeichenketten lexikografisch voneinander abweichen. Die Funktion erwartet zwei Strings und gibt eine Zahl zurück.

Syntax

compareTo(Zeichenkette zeichenkette1, Zeichenkette zeichenkette2)

Parameter

  • zeichenkette1 - erste zu vergleichende Zeichenkette
  • zeichenkette2 - zweite zu vergleichende Zeichenkette

Return Value

  • Gibt eine Zahl zurück

Beispiele

Standardfälle

compareTo('hallo','hallo')   --> returns 0

compareTo('hallo','JACK')   --> returns 30

compareTo('JACK','jack')   --> returns -32

Benutzung mit Variablen

compareTo([var=a], [var=b])
compareTo([var=a], 'JACK')
compareTo('hallo', [var=b])

Benutzung mit studentischen Eingaben

Jack2:
compareTo([pos=1], [pos=2])
compareTo([pos=1], 'JACK')
compareTo('hallo', [pos=2])

Jack3:
compareTo([input=field1], [input=field2])
compareTo([input=field1], 'JACK')
compareTo('hallo', [input=field2])

compareTo([var=a], [input=field1])
compareTo([input=field1], [var=b])

Hinweise

  • Die Funktion unterscheidet zwischen Groß- und Kleinschreibung.
  • Steht der erste String lexikografisch vor dem zweiten String, ist die Rückgabe negativ. Umgekehrt ist die Rückgabe entsprechend positiv.
  • Bei der Funktion compareToIgnoreCase wird zwischen Groß- und Kleinschreibung nicht unterschieden.
  • Wenn Variablen genutzt werden muss darauf geachtet werden, dass diese die Voraussetzung erfüllen.
  • Wenn die Eingabe der Studierenden genutzt wird muss auch hier darauf geachtet werden, dass die Voraussetzungen erfüllt sind und ob diese an der Stelle genutzt werden können.
Abgerufen von „https://wiki.uni-due.de/jack/index.php?title=CompareTo&oldid=10507“