Oshgnacknak/FOP-2425-Marathon
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge commit '58e3b905b11c1e59a2dc7ada5a724b0333a8c32f' as 'solution/H02'

Browse source
This commit is contained in:
Oshgnacknak 2025-01-11 16:41:07 +01:00
commit a7157909f3
34 changed files with 3943 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
solution/H02/.editorconfig Normal file
View file

@ -0,0 +1,12 @@
# Editor configuration, see https://editorconfig.org
[*]
charset = utf-8
end_of_line = lf
indent_style = space
indent_size = 4
insert_final_newline = true
trim_trailing_whitespace = true
[{*.yml,*.json}]
indent_size = 2

87
solution/H02/.gitignore vendored Normal file
View file

@ -0,0 +1,87 @@
### Intellij ###
.idea/
*.iws
/out/
*.iml
.idea_modules/
atlassian-ide-plugin.xml
### VS-Code ###
.vscode/
.VSCodeCounter/
### Eclipse ###
.metadata
bin/
tmp/
*.tmp
*.bak
*.swp
*~.nib
local.properties
.settings/
.loadpath
.recommenders
.externalToolBuilders/
*.launch
.factorypath
.recommenders/
.apt_generated/
.project
.classpath
### Linux ###
*~
.fuse_hidden*
.directory
.Trash-*
.nfs*
### macOS ###
.DS_Store
.AppleDouble
.LSOverride
Icon
._*
.DocumentRevisions-V100
.fseventsd
.Spotlight-V100
.TemporaryItems
.Trashes
.VolumeIcon.icns
.com.apple.timemachine.donotpresent
.AppleDB
.AppleDesktop
Network Trash Folder
Temporary Items
.apdisk
### NetBeans ###
nbproject/private/
build/
nbbuild/
dist/
nbdist/
.nb-gradle/
### Windows ###
# Windows thumbnail cache files
Thumbs.db
ehthumbs.db
ehthumbs_vista.db
*.stackdump
[Dd]esktop.ini
$RECYCLE.BIN/
*.lnk
### Gradle ###
.gradle
/build/
out/
gradle-app.setting
!gradle-wrapper.jar
.gradletasknamecache
*.hprof
screenshots/
jagr.conf

4
solution/H02/README.md Normal file
View file

@ -0,0 +1,4 @@
# Musterlösung zu Hausübung 02
Beachten Sie die Hinweise zum Herunterladen, Importieren, Bearbeitern, Exportieren und Hochladen in unserem
[Studierenden-Guide](https://wiki.tudalgo.org/)

41
solution/H02/build.gradle.kts Normal file
View file

@ -0,0 +1,41 @@
plugins {
alias(libs.plugins.algomate)
alias(libs.plugins.style)
}
version = file("version").readLines().first()
exercise {
assignmentId.set("h02")
}
submission {
// ACHTUNG!
// Setzen Sie im folgenden Bereich Ihre TU-ID (NICHT Ihre Matrikelnummer!), Ihren Nachnamen und Ihren Vornamen
// in Anführungszeichen (z.B. "ab12cdef" für Ihre TU-ID) ein!
// BEISPIEL:
// studentId = "ab12cdef"
// firstName = "sol_first"
// lastName = "sol_last"
studentId = "ab12cdef"
firstName = "sol_first"
lastName = "sol_last"
// Optionally require own tests for mainBuildSubmission task. Default is false
requireTests = false
}
dependencies {
implementation(libs.fopbot)
}
jagr {
graders {
val graderPublic by getting
val graderPrivate by creating {
parent(graderPublic)
graderName.set("FOP-2425-H02-Private")
rubricProviderName.set("h02.H02_RubricProvider")
}
}
}

6
solution/H02/gradle/libs.versions.toml Normal file
View file

@ -0,0 +1,6 @@
[plugins]
algomate = { id = "org.tudalgo.algomate", version = "0.7.1" }
style = { id = "org.sourcegrade.style", version = "3.0.0" }
[libraries]
fopbot = { module = "org.tudalgo:fopbot", version = "0.8.1" }

BIN
solution/H02/gradle/wrapper/gradle-wrapper.jar vendored Normal file
View file

Binary file not shown.

6
solution/H02/gradle/wrapper/gradle-wrapper.properties vendored Normal file
View file

@ -0,0 +1,6 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-all.zip
networkTimeout=10000
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

245
solution/H02/gradlew vendored Executable file
View file

@ -0,0 +1,245 @@
#!/bin/sh
#
# Copyright © 2015-2021 the original authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
##############################################################################
#
# Gradle start up script for POSIX generated by Gradle.
#
# Important for running:
#
# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
# noncompliant, but you have some other compliant shell such as ksh or
# bash, then to run this script, type that shell name before the whole
# command line, like:
#
# ksh Gradle
#
# Busybox and similar reduced shells will NOT work, because this script
# requires all of these POSIX shell features:
# * functions;
# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
# * compound commands having a testable exit status, especially «case»;
# * various built-in commands including «command», «set», and «ulimit».
#
# Important for patching:
#
# (2) This script targets any POSIX shell, so it avoids extensions provided
# by Bash, Ksh, etc; in particular arrays are avoided.
#
# The "traditional" practice of packing multiple parameters into a
# space-separated string is a well documented source of bugs and security
# problems, so this is (mostly) avoided, by progressively accumulating
# options in "$@", and eventually passing that to Java.
#
# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
# see the in-line comments for details.
#
# There are tweaks for specific operating systems such as AIX, CygWin,
# Darwin, MinGW, and NonStop.
#
# (3) This script is generated from the Groovy template
# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
# within the Gradle project.
#
# You can find Gradle at https://github.com/gradle/gradle/.
#
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
app_path=$0
# Need this for daisy-chained symlinks.
while
APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
[ -h "$app_path" ]
do
ls=$( ls -ld "$app_path" )
link=${ls#*' -> '}
case $link in #(
/*) app_path=$link ;; #(
*) app_path=$APP_HOME$link ;;
esac
done
# This is normally unused
# shellcheck disable=SC2034
APP_BASE_NAME=${0##*/}
APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum
warn () {
echo "$*"
} >&2
die () {
echo
echo "$*"
echo
exit 1
} >&2
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "$( uname )" in #(
CYGWIN* ) cygwin=true ;; #(
Darwin* ) darwin=true ;; #(
MSYS* | MINGW* ) msys=true ;; #(
NONSTOP* ) nonstop=true ;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD=$JAVA_HOME/jre/sh/java
else
JAVACMD=$JAVA_HOME/bin/java
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD=java
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
case $MAX_FD in #(
max*)
# In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC3045
MAX_FD=$( ulimit -H -n ) ||
warn "Could not query maximum file descriptor limit"
esac
case $MAX_FD in #(
'' | soft) :;; #(
*)
# In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC3045
ulimit -n "$MAX_FD" ||
warn "Could not set maximum file descriptor limit to $MAX_FD"
esac
fi
# Collect all arguments for the java command, stacking in reverse order:
# * args from the command line
# * the main class name
# * -classpath
# * -D...appname settings
# * --module-path (only if needed)
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
JAVACMD=$( cygpath --unix "$JAVACMD" )
# Now convert the arguments - kludge to limit ourselves to /bin/sh
for arg do
if
case $arg in #(
-*) false ;; # don't mess with options #(
/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
[ -e "$t" ] ;; #(
*) false ;;
esac
then
arg=$( cygpath --path --ignore --mixed "$arg" )
fi
# Roll the args list around exactly as many times as the number of
# args, so each arg winds up back in the position where it started, but
# possibly modified.
#
# NB: a `for` loop captures its iteration list before it begins, so
# changing the positional parameters here affects neither the number of
# iterations, nor the values presented in `arg`.
shift # remove old arg
set -- "$@" "$arg" # push replacement arg
done
fi
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Collect all arguments for the java command;
# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
# shell script including quotes and variable substitutions, so put them in
# double quotes to make sure that they get re-expanded; and
# * put everything else in single quotes, so that it's not re-expanded.
set -- \
"-Dorg.gradle.appname=$APP_BASE_NAME" \
-classpath "$CLASSPATH" \
org.gradle.wrapper.GradleWrapperMain \
"$@"
# Stop when "xargs" is not available.
if ! command -v xargs >/dev/null 2>&1
then
die "xargs is not available"
fi
# Use "xargs" to parse quoted args.
#
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
#
# In Bash we could simply go:
#
# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
# set -- "${ARGS[@]}" "$@"
#
# but POSIX shell has neither arrays nor command substitution, so instead we
# post-process each arg (as a line of input to sed) to backslash-escape any
# character that might be a shell metacharacter, then use eval to reverse
# that process (while maintaining the separation between arguments), and wrap
# the whole thing up as a single "set" statement.
#
# This will of course break if any of these variables contains a newline or
# an unmatched quote.
#
eval "set -- $(
printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
xargs -n1 |
sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
tr '\n' ' '
)" '"$@"'
exec "$JAVACMD" "$@"

92
solution/H02/gradlew.bat vendored Normal file
View file

@ -0,0 +1,92 @@
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@if "%DEBUG%"=="" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%"=="" set DIRNAME=.
@rem This is normally unused
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if %ERRORLEVEL% equ 0 goto execute
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto execute
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
:end
@rem End local scope for the variables with windows NT shell
if %ERRORLEVEL% equ 0 goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
set EXIT_CODE=%ERRORLEVEL%
if %EXIT_CODE% equ 0 set EXIT_CODE=1
if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
exit /b %EXIT_CODE%
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega

11
solution/H02/settings.gradle.kts Normal file
View file

@ -0,0 +1,11 @@
dependencyResolutionManagement {
repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
repositories {
// mavenLocal()
maven("https://s01.oss.sonatype.org/content/repositories/snapshots")
maven("https://jitpack.io")
mavenCentral()
}
}
rootProject.name = "H02-Root"

748
solution/H02/src/graderPrivate/java/h02/FourWinsTest.java Normal file
View file

@ -0,0 +1,748 @@
package h02;
import fopbot.Direction;
import fopbot.Robot;
import fopbot.RobotFamily;
import fopbot.RobotTrace;
import fopbot.Transition;
import fopbot.World;
import h02.template.InputHandler;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.stubbing.Answer;
import org.sourcegrade.jagr.api.rubric.TestForSubmission;
import org.tudalgo.algoutils.tutor.general.annotation.SkipAfterFirstFailedTest;
import org.tudalgo.algoutils.tutor.general.assertions.Assertions2;
import org.tudalgo.algoutils.tutor.general.assertions.Context;
import org.tudalgo.algoutils.tutor.general.assertions.PreCommentSupplier;
import org.tudalgo.algoutils.tutor.general.assertions.ResultOfObject;
import org.tudalgo.algoutils.tutor.general.json.JsonParameterSet;
import org.tudalgo.algoutils.tutor.general.json.JsonParameterSetTest;
import spoon.reflect.code.CtInvocation;
import spoon.reflect.code.CtLoop;
import spoon.reflect.declaration.CtElement;
import spoon.reflect.declaration.CtMethod;
import spoon.reflect.reference.CtExecutableReference;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import static h02.TestUtils.getCtMethod;
import static h02.TestUtils.iterateMethodStatements;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.assertCallEquals;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.assertCallFalse;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.assertEquals;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.assertSame;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.assertTrue;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.call;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.callObject;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.contextBuilder;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.emptyContext;
@TestForSubmission
@Timeout(
value = TestConstants.TEST_TIMEOUT_IN_SECONDS,
unit = TimeUnit.SECONDS,
threadMode = Timeout.ThreadMode.SEPARATE_THREAD
)
@SkipAfterFirstFailedTest(TestConstants.SKIP_AFTER_FIRST_FAILED_TEST)
public class FourWinsTest {
private static final Consumer<Iterator<CtElement>> SINGLE_LOOP_VA = iterator -> {
int loopStatements = 0;
while (iterator.hasNext()) {
if (iterator.next() instanceof CtLoop) {
loopStatements++;
}
}
assertEquals(1, loopStatements, emptyContext(), result -> "Method does not use exactly one loop");
};
private int worldHeight;
private int worldWidth;
private RobotFamily[][] stones;
private RobotFamily currentPlayer;
private Context.Builder<?> baseContextBuilder;
public void setup(JsonParameterSet params) {
worldHeight = params.getInt("worldHeight");
worldWidth = params.getInt("worldWidth");
List<List<String>> paramStones = params.get("gameBoard");
stones = new RobotFamily[worldHeight][worldWidth];
for (int row = 0; row < worldHeight; row++) {
for (int col = 0; col < worldWidth; col++) {
stones[row][col] = robotFamilyLookup(paramStones.get(row).get(col));
}
}
baseContextBuilder = contextBuilder()
.add("world height", worldHeight)
.add("world width", worldWidth)
.add("stones", stones);
if (params.availableKeys().contains("currentPlayer")) {
currentPlayer = robotFamilyLookup(params.get("currentPlayer"));
baseContextBuilder.add("currentPlayer", currentPlayer);
}
World.setSize(worldWidth, worldHeight);
World.setDelay(0);
}
@ParameterizedTest
@JsonParameterSetTest(value = "FourWinsTestValidateInput.json")
public void testValidateInputEdgeCases(final JsonParameterSet params) {
testValidateInput(params);
}
@ParameterizedTest
@JsonParameterSetTest(value = "FourWinsTestValidateInputRandomCases.generated.json")
public void testValidateInputRandomCases(final JsonParameterSet params) {
testValidateInput(params);
}
public void testValidateInput(final JsonParameterSet params) {
// get params
final int paramColumn = params.getInt("column");
final int paramWidth = params.getInt("width");
final int paramHeight = params.getInt("height");
final List<List<String>> paramStones = params.get("stones");
final boolean expectedResult = params.getBoolean("expected result");
// write params to context
final var ParamsContext = params.toContext("expected result");
final var cb = contextBuilder()
.add(ParamsContext)
.add("Method", "validateInput");
// init the world size
World.setSize(paramWidth, paramHeight);
// parse array and calculate result
RobotFamily[][] paramStonesArray = paramStones.stream()
.map(innerList -> innerList.stream()
.map(str -> "EMPTY".equals(str) ? null : "SQUARE_RED".equals(str) ? RobotFamily.SQUARE_RED :
RobotFamily.SQUARE_BLUE)
.toArray(RobotFamily[]::new))
.toArray(RobotFamily[][]::new);
final boolean actualResult = Assertions2.callObject(
() -> FourWins.validateInput(
paramColumn,
paramStonesArray
),
cb.build(),
r -> "An error occurred during execution."
);
// validate result
Assertions2.assertEquals(
expectedResult,
actualResult,
cb.build(),
r -> "Invalid result."
);
}
@ParameterizedTest
@JsonParameterSetTest("FourWinsTestGameBoard.generated.json")
public void testGetDestinationRowFreeSlot(JsonParameterSet params) {
testGetDestinationRow(params, true);
}
@ParameterizedTest
@JsonParameterSetTest("FourWinsTestGameBoard.generated.json")
public void testGetDestinationRowBlockedSlot(JsonParameterSet params) {
testGetDestinationRow(params, false);
}
@Test
public void testGetDestinationRowVAnforderung() {
iterateMethodStatements(FourWins.class,
"getDestinationRow",
new Class[] {int.class, RobotFamily[][].class},
SINGLE_LOOP_VA);
}
@ParameterizedTest
@JsonParameterSetTest("FourWinsTestGameBoard.generated.json")
public void testDropStoneRobotCorrect(JsonParameterSet params) {
setup(params);
List<Integer> firstFreeIndex = params.get("firstFreeIndex");
for (int col = 0; col < worldWidth; col++) {
if (firstFreeIndex.get(col) >= worldHeight) {
continue;
}
World.getGlobalWorld().reset(); // clear entities
RobotFamily currentPlayer = col % 2 == 0 ? RobotFamily.SQUARE_RED : RobotFamily.SQUARE_BLUE;
Context context = baseContextBuilder
.add("column", col)
.add("currentPlayer", currentPlayer)
.build();
try {
final int finalCol = col;
call(() -> FourWins.dropStone(finalCol, stones, currentPlayer), context, result ->
"An exception occurred while invoking method dropStone. Result may be salvageable, continuing...");
} catch (Throwable t) {
t.printStackTrace(System.err);
}
List<Robot> robots = World.getGlobalWorld()
.getAllFieldEntities()
.stream()
.filter(fieldEntity -> fieldEntity instanceof Robot)
.map(fieldEntity -> (Robot) fieldEntity)
.toList();
assertEquals(1, robots.size(), context, result ->
"Unexpected number of robots in world");
RobotTrace trace = World.getGlobalWorld().getTrace(robots.get(0));
Robot robot = trace.getTransitions().get(0).robot;
assertEquals(col, robot.getX(), context, result ->
"Robot was initialized with incorrect x coordinate");
assertEquals(worldHeight - 1, robot.getY(), context, result ->
"Robot was initialized with incorrect y coordinate");
assertEquals(Direction.DOWN, robot.getDirection(), context, result ->
"Robot was initialized with incorrect direction");
assertEquals(0, robot.getNumberOfCoins(), context, result ->
"Robot was initialized with incorrect number of coins");
assertEquals(currentPlayer, robot.getRobotFamily(), context, result ->
"Robot was initialized with incorrect robot family");
}
}
@Test
public void testDropStoneCallsGetDestinationRow() {
CtMethod<?> dropStoneCtMethod = getCtMethod(FourWins.class, "dropStone", int.class, RobotFamily[][].class, RobotFamily.class);
CtExecutableReference<?> getDestinationRowCtExecRef = getCtMethod(FourWins.class, "getDestinationRow", int.class, RobotFamily[][].class)
.getReference();
Iterator<CtElement> iterator = dropStoneCtMethod.descendantIterator();
boolean getDestinationRowCalled = false;
while (!getDestinationRowCalled && iterator.hasNext()) {
CtElement ctElement = iterator.next();
if (ctElement instanceof CtInvocation<?> ctInvocation) {
getDestinationRowCalled = ctInvocation.getExecutable().equals(getDestinationRowCtExecRef);
}
}
assertTrue(getDestinationRowCalled, emptyContext(), result ->
"Method dropStone does not call method getDestinationRow");
}
@ParameterizedTest
@JsonParameterSetTest("FourWinsTestGameBoard.generated.json")
public void testDropStoneMovementCorrect(JsonParameterSet params) {
setup(params);
List<Integer> firstFreeIndex = params.get("firstFreeIndex");
for (int col = 0; col < worldWidth; col++) {
if (firstFreeIndex.get(col) >= worldHeight) {
continue;
}
World.getGlobalWorld().reset(); // clear entities
RobotFamily currentPlayer = RobotFamily.SQUARE_RED;
Context context = baseContextBuilder
.add("column", col)
.add("currentPlayer", currentPlayer)
.build();
try {
final int finalCol = col;
call(() -> FourWins.dropStone(finalCol, stones, currentPlayer), context, result ->
"An exception occurred while invoking method dropStone. Result may be salvageable, continuing...");
} catch (Throwable t) {
t.printStackTrace(System.err);
}
List<Robot> robots = World.getGlobalWorld()
.getAllFieldEntities()
.stream()
.filter(Robot.class::isInstance)
.map(Robot.class::cast)
.toList();
assertEquals(1, robots.size(), context, result ->
"Unexpected number of robots in world");
List<Transition> transitions = World.getGlobalWorld().getTrace(robots.get(0)).getTransitions();
int expectedTransitionsSize = worldHeight - 1 - firstFreeIndex.get(col) + 3;
for (int i = 0; i < expectedTransitionsSize; i++) {
Transition transition = transitions.get(i);
final int finalI = i;
PreCommentSupplier<ResultOfObject<Transition.RobotAction>> preCommentSupplier = result ->
"Robot did not perform the expected action (action number %d)".formatted(finalI);
if (i < expectedTransitionsSize - 3) { // moving
assertEquals(Transition.RobotAction.MOVE, transition.action, context, preCommentSupplier);
} else if (i < expectedTransitionsSize - 1) { // left turns
assertEquals(Transition.RobotAction.TURN_LEFT, transition.action, context, preCommentSupplier);
} else { // last action (none)
assertEquals(Transition.RobotAction.NONE, transition.action, context, preCommentSupplier);
}
}
}
}
@Test
public void testDropStoneVAnforderung() {
iterateMethodStatements(FourWins.class,
"dropStone",
new Class[] {int.class, RobotFamily[][].class, RobotFamily.class},
SINGLE_LOOP_VA);
}
@ParameterizedTest
@JsonParameterSetTest("FourWinsTestGameBoardHorizontalWin.generated.json")
public void testTestWinHorizontal(JsonParameterSet params) {
setup(params);
List<Map<String, Integer>> winningRowCoordinates = params.get("winningRowCoordinates");
Context context = baseContextBuilder.build();
boolean expected = !winningRowCoordinates.isEmpty();
boolean actual = callObject(() -> FourWins.testWinHorizontal(stones, currentPlayer), context, result ->
"An exception occurred while invoking method testWinHorizontal");
assertEquals(expected, actual, context, result ->
"Method testWinHorizontal did not return the correct value");
}
@Test
public void testTestWinHorizontalVAnforderung1() {
testWinVAnforderung("testWinHorizontal");
}
@Test
public void testTestWinHorizontalVAnforderung2() {
int worldHeight = 5;
int worldWidth = 5;
RobotFamily[][] stones = new RobotFamily[worldHeight][worldWidth];
for (int row = 0; row < 4; row++) {
stones[row][0] = RobotFamily.SQUARE_RED;
}
RobotFamily currentPlayer = RobotFamily.SQUARE_RED;
Context context = contextBuilder()
.add("world height", worldHeight)
.add("world width", worldWidth)
.add("stones", stones)
.add("currentPlayer", currentPlayer)
.build();
World.setSize(worldWidth, worldHeight);
assertCallFalse(() -> FourWins.testWinHorizontal(stones, currentPlayer), context, result ->
"Method testWinHorizontal returned an incorrect value");
}
@ParameterizedTest
@JsonParameterSetTest("FourWinsTestGameBoardVerticalWin.generated.json")
public void testTestWinVertical(JsonParameterSet params) {
setup(params);
List<Map<String, Integer>> winningColCoordinates = params.get("winningColCoordinates");
Context context = baseContextBuilder.build();
boolean expected = !winningColCoordinates.isEmpty();
boolean actual = callObject(() -> FourWins.testWinVertical(stones, currentPlayer), context, result ->
"An exception occurred while invoking method testWinVertical");
assertEquals(expected, actual, context, result ->
"Method testWinVertical did not return the correct value");
}
@Test
public void testTestWinVerticalVAnforderung1() {
testWinVAnforderung("testWinVertical");
}
@Test
public void testTestWinVerticalVAnforderung2() {
int worldHeight = 5;
int worldWidth = 5;
RobotFamily[][] stones = new RobotFamily[worldHeight][worldWidth];
for (int col = 0; col < 4; col++) {
stones[0][col] = RobotFamily.SQUARE_RED;
}
RobotFamily currentPlayer = RobotFamily.SQUARE_RED;
Context context = contextBuilder()
.add("world height", worldHeight)
.add("world width", worldWidth)
.add("stones", stones)
.add("currentPlayer", currentPlayer)
.build();
World.setSize(worldWidth, worldHeight);
assertCallFalse(() -> FourWins.testWinVertical(stones, currentPlayer), context, result ->
"Method testWinVertical returned an incorrect value");
}
/**
* Tests {@link FourWins#testWinConditions(RobotFamily[][], RobotFamily)}.
* The parameter {@code flags} is used to determine the return value of the win condition methods,
* where a set bit is interpreted as {@code true} and an unset bit as {@code false}.
* Only the first three bits are evaluated and correspond to the methods as follows:
* <ul>
* <li>Bit 0: {@link FourWins#testWinHorizontal(RobotFamily[][], RobotFamily)}</li>
* <li>Bit 1: {@link FourWins#testWinVertical(RobotFamily[][], RobotFamily)}</li>
* <li>Bit 2: {@link FourWins#testWinDiagonal(RobotFamily[][], RobotFamily)}</li>
* </ul>
*
* @param flags the flags (2:0, 31:3 are unused)
* @throws ReflectiveOperationException if methods testWinHorizontal, testWinVertical or testWinDiagonal are not found
*/
@ParameterizedTest
@ValueSource(ints = {0, 1, 2, 3, 4, 5, 6, 7})
public void testTestWinConditions(int flags) throws ReflectiveOperationException {
Method testWinHorizontalMethod = FourWins.class.getDeclaredMethod("testWinHorizontal", RobotFamily[][].class, RobotFamily.class);
Method testWinVerticalMethod = FourWins.class.getDeclaredMethod("testWinVertical", RobotFamily[][].class, RobotFamily.class);
Method testWinDiagonalMethod = FourWins.class.getDeclaredMethod("testWinDiagonal", RobotFamily[][].class, RobotFamily.class);
Answer<?> answer = invocation -> {
if (invocation.getMethod().equals(testWinHorizontalMethod)) {
return (flags & 1) == 1;
} else if (invocation.getMethod().equals(testWinVerticalMethod)) {
return (flags >> 1 & 1) == 1;
} else if (invocation.getMethod().equals(testWinDiagonalMethod)) {
return (flags >> 2 & 1) == 1;
} else {
return invocation.callRealMethod();
}
};
int worldHeight = 5;
int worldWidth = 5;
RobotFamily[][] stones = new RobotFamily[worldHeight][worldWidth];
RobotFamily currentPlayer = RobotFamily.SQUARE_RED;
Context context = contextBuilder()
.add("world height", worldHeight)
.add("world width", worldWidth)
.add("stones (ignored)", stones)
.add("currentPlayer (ignored)", currentPlayer.getName())
.add("testWinHorizontal (mocked) return value", (flags & 1) == 1)
.add("testWinVertical (mocked) return value", (flags >> 1 & 1) == 1)
.add("testWinDiagonal (mocked) return value", (flags >> 2 & 1) == 1)
.build();
World.setSize(worldWidth, worldHeight);
try (MockedStatic<FourWins> mock = Mockito.mockStatic(FourWins.class, answer)) {
assertCallEquals(flags != 0, () -> FourWins.testWinConditions(stones, currentPlayer), context, result ->
"Method testWinConditions did not return the correct value");
}
}
@Test
public void testTestWinConditionsVAnforderung() {
iterateMethodStatements(FourWins.class, "testWinConditions", new Class[] {RobotFamily[][].class, RobotFamily.class}, iterator -> {
boolean callsTestWinHorizontal = false;
boolean callsTestWinVertical = false;
boolean callsTestWinDiagonal = false;
while (iterator.hasNext()) {
if (iterator.next() instanceof CtInvocation<?> ctInvocation) {
if (ctInvocation.getExecutable().getSimpleName().equals("testWinHorizontal")) {
callsTestWinHorizontal = true;
} else if (ctInvocation.getExecutable().getSimpleName().equals("testWinVertical")) {
callsTestWinVertical = true;
} else if (ctInvocation.getExecutable().getSimpleName().equals("testWinDiagonal")) {
callsTestWinDiagonal = true;
}
}
}
assertTrue(callsTestWinHorizontal, emptyContext(), result -> "Method testWinConditions did not call testWinHorizontal");
assertTrue(callsTestWinVertical, emptyContext(), result -> "Method testWinConditions did not call testWinVertical");
assertTrue(callsTestWinDiagonal, emptyContext(), result -> "Method testWinConditions did not call testWinDiagonal");
});
}
@ParameterizedTest
@ValueSource(booleans = {true, false})
public void testNextPlayer(boolean isRedPlayer) {
RobotFamily currentPlayer = isRedPlayer ? RobotFamily.SQUARE_RED : RobotFamily.SQUARE_BLUE;
Context context = contextBuilder()
.add("currentPlayer", currentPlayer)
.build();
RobotFamily expected = isRedPlayer ? RobotFamily.SQUARE_BLUE : RobotFamily.SQUARE_RED;
assertCallEquals(expected, () -> FourWins.nextPlayer(currentPlayer), context, result ->
"Method nextPlayer did not return the correct value");
}
@ParameterizedTest
@ValueSource(booleans = {true, false})
public void testColorFieldBackground(boolean isRedPlayer) {
int worldHeight = 5;
int worldWidth = 5;
RobotFamily winner = isRedPlayer ? RobotFamily.SQUARE_RED : RobotFamily.SQUARE_BLUE;
Context context = contextBuilder()
.add("world height", worldHeight)
.add("world width", worldWidth)
.add("winner", winner)
.build();
World.setSize(worldWidth, worldHeight);
World.setDelay(0);
call(() -> FourWins.colorFieldBackground(winner), context, result ->
"An exception occurred while invoking colorFieldBackground");
for (int row = 0; row < worldHeight; row++) {
for (int col = 0; col < worldWidth; col++) {
int finalRow = row;
int finalCol = col;
assertEquals(winner.getColor(), World.getGlobalWorld().getFieldColor(col, row), context, result ->
"Color of field at row %d, column %d is incorrect".formatted(finalRow, finalCol));
}
}
}
@Test
public void testWriteMessages() {
PrintStream originalOut = System.out;
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
PrintStream printStream = new PrintStream(outputStream, true);
System.setOut(printStream);
int worldHeight = 5;
int worldWidth = 5;
FourWins fourWinsInstance = new FourWins(worldWidth, worldHeight);
Context.Builder<?> contextBuilder = contextBuilder()
.add("world height", worldHeight)
.add("world width", worldWidth);
World.setSize(worldWidth, worldHeight);
try {
contextBuilder.add("method", "writeDrawMessage");
fourWinsInstance.writeDrawMessage();
assertEquals(
"No valid columns found. Hence, game ends with a draw.",
outputStream.toString().strip(),
contextBuilder.build(),
result -> "Method did not print the correct string"
);
contextBuilder.add("method", "writeWinnerMessage");
for (RobotFamily winner : new RobotFamily[] {RobotFamily.SQUARE_RED, RobotFamily.SQUARE_BLUE}) {
contextBuilder.add("winner", winner);
outputStream.reset();
fourWinsInstance.writeWinnerMessage(winner);
assertEquals(
"Player %s wins the game!".formatted(winner),
outputStream.toString().strip(),
contextBuilder.build(),
result -> "Method did not print the correct string"
);
}
} finally {
System.setOut(originalOut);
}
}
@Test
public void testGameLoopCallsNextPlayer() {
List<RobotFamily> nextPlayerArgs = new ArrayList<>();
Answer<?> answer = invocation -> {
Method method = invocation.getMethod();
if (method.getName().equals("nextPlayer") && Arrays.equals(method.getParameterTypes(), new Class[] {RobotFamily.class})) {
RobotFamily currentPlayer = invocation.getArgument(0);
nextPlayerArgs.add(currentPlayer);
return currentPlayer == RobotFamily.SQUARE_RED ? RobotFamily.SQUARE_BLUE : RobotFamily.SQUARE_RED;
} else if (method.getName().equals("dropStone") && Arrays.equals(method.getParameterTypes(), new Class[] {int.class, RobotFamily[][].class, RobotFamily.class})) {
return null;
} else if (method.getName().equals("testWinConditions") && Arrays.equals(method.getParameterTypes(), new Class[] {RobotFamily[][].class, RobotFamily.class})) {
return nextPlayerArgs.size() >= 5;
} else {
return invocation.callRealMethod();
}
};
try (MockedStatic<FourWins> mockedStatic = Mockito.mockStatic(FourWins.class, answer)) {
int worldHeight = 5;
int worldWidth = 5;
FourWins fourWins = new FourWins(worldWidth, worldHeight);
InputHandler inputHandler = fourWins.getInputHandler();
for (int i = 0; i < 10; i++) {
inputHandler.addInput(0);
}
fourWins.startGame();
for (int i = 0; i < nextPlayerArgs.size(); i++) {
Context context = contextBuilder()
.add("world height", worldHeight)
.add("world width", worldWidth)
.add("game loop iteration", i + 1)
.build();
if (i % 2 == 0) {
assertEquals(RobotFamily.SQUARE_BLUE, nextPlayerArgs.get(i), context, result ->
"Method nextPlayer was not called with correct parameters");
} else {
assertEquals(RobotFamily.SQUARE_RED, nextPlayerArgs.get(i), context, result ->
"Method nextPlayer was not called with correct parameters");
}
}
}
}
@Test
public void testGameLoopCallsDropStone() {
List<Integer> columnArgs = new ArrayList<>();
List<RobotFamily[][]> stonesArgs = new ArrayList<>();
List<RobotFamily> currentPlayerArgs = new ArrayList<>();
Answer<?> answer = invocation -> {
Method method = invocation.getMethod();
if (method.getName().equals("nextPlayer") && Arrays.equals(method.getParameterTypes(), new Class[] {RobotFamily.class})) {
RobotFamily currentPlayer = invocation.getArgument(0);
return currentPlayer == RobotFamily.SQUARE_RED ? RobotFamily.SQUARE_BLUE : RobotFamily.SQUARE_RED;
} else if (method.getName().equals("dropStone") && Arrays.equals(method.getParameterTypes(), new Class[] {int.class, RobotFamily[][].class, RobotFamily.class})) {
columnArgs.add(invocation.getArgument(0));
stonesArgs.add(invocation.getArgument(1));
currentPlayerArgs.add(invocation.getArgument(2));
return null;
} else if (method.getName().equals("testWinConditions") && Arrays.equals(method.getParameterTypes(), new Class[] {RobotFamily[][].class, RobotFamily.class})) {
return currentPlayerArgs.size() >= 5;
} else {
return invocation.callRealMethod();
}
};
int worldHeight = 5;
int worldWidth = 5;
try (MockedStatic<FourWins> mockedStatic = Mockito.mockStatic(FourWins.class, answer)) {
FourWins fourWins = new FourWins(worldWidth, worldHeight);
InputHandler inputHandler = fourWins.getInputHandler();
for (int i = 0; i < 10; i++) {
inputHandler.addInput(i % worldWidth);
}
fourWins.startGame();
}
RobotFamily[][] stones = null;
for (int i = 0; i < currentPlayerArgs.size(); i++) {
if (stones == null) {
stones = stonesArgs.get(i);
}
Context context = contextBuilder()
.add("world height", worldHeight)
.add("world width", worldWidth)
.add("game loop iteration", i + 1)
.build();
assertEquals(i % worldWidth, columnArgs.get(i), context, result ->
"Method dropStone was not called with correct parameter column");
assertSame(stones, stonesArgs.get(i), context, result ->
"Method dropStone was not called with correct parameter stones");
if (i % 2 == 0) {
assertEquals(RobotFamily.SQUARE_RED, currentPlayerArgs.get(i), context, result ->
"Method dropStone was not called with correct parameter currentPlayer");
} else {
assertEquals(RobotFamily.SQUARE_BLUE, currentPlayerArgs.get(i), context, result ->
"Method dropStone was not called with correct parameter currentPlayer");
}
}
}
@Test
public void testGameLoopCallsGetWinConditions() {
List<RobotFamily[][]> stonesArgs = new ArrayList<>();
List<RobotFamily> currentPlayerArgs = new ArrayList<>();
Answer<?> answer = invocation -> {
Method method = invocation.getMethod();
if (method.getName().equals("nextPlayer") && Arrays.equals(method.getParameterTypes(), new Class[] {RobotFamily.class})) {
RobotFamily currentPlayer = invocation.getArgument(0);
return currentPlayer == RobotFamily.SQUARE_RED ? RobotFamily.SQUARE_BLUE : RobotFamily.SQUARE_RED;
} else if (method.getName().equals("dropStone") && Arrays.equals(method.getParameterTypes(), new Class[] {int.class, RobotFamily[][].class, RobotFamily.class})) {
return null;
} else if (method.getName().equals("testWinConditions") && Arrays.equals(method.getParameterTypes(), new Class[] {RobotFamily[][].class, RobotFamily.class})) {
stonesArgs.add(invocation.getArgument(0));
currentPlayerArgs.add(invocation.getArgument(1));
return currentPlayerArgs.size() >= 5;
} else {
return invocation.callRealMethod();
}
};
int worldHeight = 5;
int worldWidth = 5;
try (MockedStatic<FourWins> mockedStatic = Mockito.mockStatic(FourWins.class, answer)) {
FourWins fourWins = new FourWins(worldWidth, worldHeight);
InputHandler inputHandler = fourWins.getInputHandler();
for (int i = 0; i < 10; i++) {
inputHandler.addInput(i % worldWidth);
}
fourWins.startGame();
}
RobotFamily[][] stones = null;
for (int i = 0; i < currentPlayerArgs.size(); i++) {
if (stones == null) {
stones = stonesArgs.get(i);
}
Context context = contextBuilder()
.add("world height", worldHeight)
.add("world width", worldWidth)
.add("game loop iteration", i + 1)
.build();
assertSame(stones, stonesArgs.get(i), context, result ->
"Method getWinConditions was not called with correct parameter stones");
if (i % 2 == 0) {
assertEquals(RobotFamily.SQUARE_RED, currentPlayerArgs.get(i), context, result ->
"Method getWinConditions was not called with correct parameter currentPlayer");
} else {
assertEquals(RobotFamily.SQUARE_BLUE, currentPlayerArgs.get(i), context, result ->
"Method getWinConditions was not called with correct parameter currentPlayer");
}
}
}
private void testGetDestinationRow(JsonParameterSet params, boolean testFreeSlots) {
setup(params);
List<Integer> firstFreeIndex = params.get("firstFreeIndex");
for (int i = 0; i < firstFreeIndex.size(); i++) {
int index = firstFreeIndex.get(i);
if ((testFreeSlots && index >= worldHeight) || (!testFreeSlots && index < worldHeight)) {
continue;
}
final int column = i;
int expected = testFreeSlots ? index : -1;
Context context = baseContextBuilder
.add("column", column)
.build();
int actual = callObject(() -> FourWins.getDestinationRow(column, stones), context, result ->
"An exception occurred while invoking method getDestinationRow");
assertEquals(expected, actual, context, result ->
"Method getDestinationRow returned an incorrect value");
}
}
private void testWinVAnforderung(String methodName) {
List<CtLoop> loops = getCtMethod(FourWins.class, methodName, RobotFamily[][].class, RobotFamily.class)
.filterChildren(CtLoop.class::isInstance)
.list();
assertEquals(2, loops.size(), emptyContext(), result ->
"Method %s does not use exactly two loops".formatted(methodName));
assertTrue(loops.get(0).getBody().equals(loops.get(1).getParent()), emptyContext(), result ->
"Method %s does not use exactly two nested loops".formatted(methodName));
}
private static RobotFamily robotFamilyLookup(String robotFamilyName) {
if (robotFamilyName == null) {
return null;
}
return switch (robotFamilyName) {
case "SQUARE_RED" -> RobotFamily.SQUARE_RED;
case "SQUARE_BLUE" -> RobotFamily.SQUARE_BLUE;
default -> null;
};
}
}

367
solution/H02/src/graderPrivate/java/h02/H02_RubricProvider.java Normal file
View file

@ -0,0 +1,367 @@
package h02;
import org.sourcegrade.jagr.api.rubric.Criterion;
import org.sourcegrade.jagr.api.rubric.JUnitTestRef;
import org.sourcegrade.jagr.api.rubric.Rubric;
import org.sourcegrade.jagr.api.rubric.RubricProvider;
import org.sourcegrade.jagr.api.testing.RubricConfiguration;
import org.tudalgo.algoutils.tutor.general.json.JsonParameterSet;
import static org.tudalgo.algoutils.tutor.general.jagr.RubricUtils.criterion;
public class H02_RubricProvider implements RubricProvider {
public static final Rubric RUBRIC = Rubric.builder()
.title("H02 | Vier Gewinnt")
.addChildCriteria(
Criterion.builder()
.shortDescription("H2.1 | Grundlagen-Training")
.minPoints(0)
.addChildCriteria(
Criterion.builder()
.shortDescription("H2.1.1 | Fibonacci mit 1D Array")
.minPoints(0)
.addChildCriteria(
criterion(
"Methode push: Das letzte Element des Ergebnis-Arrays ist das übergebene Element.",
JUnitTestRef.ofMethod(
() -> OneDimensionalArrayStuffTest.class.getDeclaredMethod(
"testPushLastElementCorrect",
JsonParameterSet.class
)
)
),
criterion(
"Methode push: Die Elemente des Ergebnis-Arrays sind korrekt.",
JUnitTestRef.ofMethod(
() -> OneDimensionalArrayStuffTest.class.getDeclaredMethod(
"testPushAllElementsCorrect",
JsonParameterSet.class
)
)
),
criterion(
"Methode push: Das Eingabe-Array wird nicht verändert.",
JUnitTestRef.ofMethod(
() -> OneDimensionalArrayStuffTest.class.getDeclaredMethod(
"testPushOriginalArrayUnchanged",
JsonParameterSet.class
)
)
),
criterion(
"Methode calculateNextFibonacci: Das Ergebnis ist korrekt mit zwei positiven Zahlen.",
JUnitTestRef.ofMethod(
() -> OneDimensionalArrayStuffTest.class.getDeclaredMethod(
"testCalculateNextFibonacciPositiveOnly", JsonParameterSet.class)
)
),
criterion(
"Methode calculateNextFibonacci: Das Ergebnis ist korrekt mit beliebigen Eingaben.",
JUnitTestRef.ofMethod(
() -> OneDimensionalArrayStuffTest.class.getDeclaredMethod(
"testCalculateNextFibonacciAllNumbers", JsonParameterSet.class)
)
),
criterion(
"Methode calculateNextFibonacci: Eine verbindliche Anforderung wurde verletzt.",
JUnitTestRef.ofMethod(
() -> OneDimensionalArrayStuffTest.class.getDeclaredMethod(
"testCalculateNextFibonacciVanforderungen", JsonParameterSet.class)
),
-1
),
criterion(
"Methode fibonacci: Das Ergebnis ist korrekt für n < 2.",
JUnitTestRef.ofMethod(
() -> OneDimensionalArrayStuffTest.class.getDeclaredMethod(
"testFibonacciSmallerThanTwo", JsonParameterSet.class)
)
),
criterion(
"Methode fibonacci: Das Ergebnis ist korrekt für n >= 2.",
JUnitTestRef.ofMethod(
() -> OneDimensionalArrayStuffTest.class.getDeclaredMethod(
"testFibonacciBigNumbers", JsonParameterSet.class)
)
),
criterion(
"Methode fibonacci: Eine Verbindliche Anforderung wurde verletzt.",
JUnitTestRef.and(
JUnitTestRef.ofMethod(
() -> OneDimensionalArrayStuffTest.class.getDeclaredMethod(
"testFibonacciVanforderungen", JsonParameterSet.class)
),
JUnitTestRef.ofMethod(
() -> OneDimensionalArrayStuffTest.class.getDeclaredMethod(
"testFibonacciNonIterativeVanforderungen")
)
),
-1
)
)
.build(),
Criterion.builder()
.shortDescription("H2.1.2 | Textsuche mit 2D Arrays")
.minPoints(0)
.addChildCriteria(
criterion(
"Methode occurrences: Die Methode funktioniert korrekt mit einem leeren Array.",
JUnitTestRef.ofMethod(
() -> TwoDimensionalArrayStuffTest.class.getDeclaredMethod(
"testOccurrencesEmptyArray", JsonParameterSet.class)
)
),
criterion(
"Methode occurrences: Die Methode funktioniert mit einem Satz.",
JUnitTestRef.ofMethod(
() -> TwoDimensionalArrayStuffTest.class.getDeclaredMethod(
"testOccurrencesSingleSentence", JsonParameterSet.class)
)
),
criterion(
"Methode occurrences: Die Methode funktioniert mit mehreren Sätzen.",
JUnitTestRef.ofMethod(
() -> TwoDimensionalArrayStuffTest.class.getDeclaredMethod(
"testOccurrencesMultipleSentences", JsonParameterSet.class)
)
),
criterion(
"Methode mean: Methode funktioniert mit ganzzahligen Rechenwerten.",
JUnitTestRef.ofMethod(
() -> TwoDimensionalArrayStuffTest.class.getDeclaredMethod(
"testMeanInteger", JsonParameterSet.class)
)
),
criterion(
"Methode mean: Die Methode funktioniert auch dann korrekt, wenn das Ergebnis eine fließkommazahl ist.",
JUnitTestRef.ofMethod(
() -> TwoDimensionalArrayStuffTest.class.getDeclaredMethod(
"testMeanFloat", JsonParameterSet.class)
)
)
)
.build()
)
.build()
)
.addChildCriteria(
Criterion.builder()
.shortDescription("H2.2 | Vier Gewinnt")
.minPoints(0)
.addChildCriteria(
Criterion.builder()
.shortDescription("H2.2.1 | Slot Prüfen")
.addChildCriteria(
criterion(
"Methode validateInput: Methode ist vollständig korrekt implementiert.",
JUnitTestRef.and(
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testValidateInputEdgeCases", JsonParameterSet.class)
),
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testValidateInputRandomCases", JsonParameterSet.class)
)
)
)
)
.build(),
Criterion.builder()
.shortDescription("H2.2.2 | Münzen fallen lassen")
.minPoints(0)
.addChildCriteria(
criterion(
"Methode getDestinationRow: Die Rückgabe ist korrekt, wenn ein freier Slot existiert.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testGetDestinationRowFreeSlot", JsonParameterSet.class)
)
),
criterion(
"Methode getDestinationRow: Die Rückgabe ist korrekt, wenn KEIN freier Slot existiert.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testGetDestinationRowBlockedSlot", JsonParameterSet.class)
)
),
criterion(
"Methode getDestinationRow: Verbindliche Anforderung 'genau eine Schleife' wurde verletzt.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testGetDestinationRowVAnforderung")
),
-1
),
criterion(
"Methode dropStone: Robot wird mit korrekten Parametern erstellt.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testDropStoneRobotCorrect", JsonParameterSet.class)
)
),
criterion(
"Methode dropStone: getDestinationRow wird korrekt aufgerufen.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testDropStoneCallsGetDestinationRow")
)
),
criterion(
"Methode dropStone: Robot führt die korrekte Bewegung aus.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testDropStoneMovementCorrect", JsonParameterSet.class)
)
),
criterion(
"Methode dropStone: Verbindliche Anforderung 'genau eine Schleife' wurde verletzt.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod("testDropStoneVAnforderung")
),
-1
)
)
.build(),
Criterion.builder()
.shortDescription("H2.2.3 | Gewinnbedingung prüfen")
.addChildCriteria(
Criterion.builder()
.shortDescription("Methode testWinHorizontal: ")
.addChildCriteria(
criterion(
"Methode erkennt richtige horizontale Steinfolgen.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testTestWinHorizontal", JsonParameterSet.class)
),
2
),
criterion(
"Methode nutzt genau zwei verschachtelte Schleifen.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testTestWinHorizontalVAnforderung1")
),
1
),
criterion(
"Methode erkennt keine falschen Steinfolgen.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod("testTestWinHorizontalVAnforderung2")
),
-2
)
).minPoints(0).build(),
Criterion.builder()
.shortDescription("Methode testWinVertical: ")
.addChildCriteria(
criterion(
"Methode erkennt richtige vertikale Steinfolgen.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testTestWinVertical", JsonParameterSet.class)
),
2
),
criterion(
"Methode nutzt genau zwei verschachtelte Schleifen.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testTestWinVerticalVAnforderung1")
),
1
),
criterion(
"Methode erkennt keine falschen Steinfolgen.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testTestWinVerticalVAnforderung2")
),
-2
)
).minPoints(0).build(),
Criterion.builder()
.shortDescription("Methode testWinConditions: ")
.addChildCriteria(
criterion(
"Die Rückgabe ist in allen Fällen korrekt.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testTestWinConditions", int.class)
)
),
criterion(
"testWinHorizontal, testWinVertical und testWinDiagonal werden korrekt aufgerufen.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testTestWinConditionsVAnforderung")
)
)
).build()
)
.build(),
Criterion.builder()
.shortDescription("H2.2.4 | Game Loop")
.minPoints(0)
.addChildCriteria(
criterion(
"Methode nextPlayer: Die Rückgabe für beide RobotFamily.SQUARE_BLUE und SQUARE_RED korrekt.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testNextPlayer", boolean.class)
)
),
criterion(
"Methode colorFieldBackground: Das Spielfeld wird korrekt eingefärbt.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testColorFieldBackground", boolean.class)
)
),
criterion(
"Methoden writeDrawMessage, writeWinnerMessage: Die Ausgabe in die Konsole ist korrekt.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testWriteMessages")
)
),
criterion(
"Methode gameLoop: nextPlayer wird mit korrektem Parameter aufgerufen.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testGameLoopCallsNextPlayer")
)
),
criterion(
"Methode gameLoop: dropStone wird mit korrekten Parametern aufgerufen.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testGameLoopCallsDropStone")
)
),
criterion(
"Methode gameLoop: testWinConditions wird mit korrekten Parametern aufgerufen.",
JUnitTestRef.ofMethod(
() -> FourWinsTest.class.getDeclaredMethod(
"testGameLoopCallsGetWinConditions")
)
)
)
.build()
)
.build()
)
.build();
@Override
public Rubric getRubric() {
return RUBRIC;
}
@Override
public void configure(RubricConfiguration configuration) {
configuration.addTransformer(new SubmissionTransformer());
}
}

327
solution/H02/src/graderPrivate/java/h02/OneDimensionalArrayStuffTest.java Normal file
View file

@ -0,0 +1,327 @@
package h02;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.params.ParameterizedTest;
import org.mockito.Answers;
import org.mockito.Mockito;
import org.mockito.exceptions.base.MockitoException;
import org.sourcegrade.jagr.api.rubric.TestForSubmission;
import org.tudalgo.algoutils.tutor.general.annotation.SkipAfterFirstFailedTest;
import org.tudalgo.algoutils.tutor.general.assertions.Assertions2;
import org.tudalgo.algoutils.tutor.general.assertions.Assertions4;
import org.tudalgo.algoutils.tutor.general.json.JsonParameterSet;
import org.tudalgo.algoutils.tutor.general.json.JsonParameterSetTest;
import org.tudalgo.algoutils.tutor.general.reflections.BasicMethodLink;
import spoon.reflect.code.CtInvocation;
import spoon.reflect.code.CtLocalVariable;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.contextBuilder;
@TestForSubmission
@Timeout(
value = TestConstants.TEST_TIMEOUT_IN_SECONDS,
unit = TimeUnit.SECONDS,
threadMode = Timeout.ThreadMode.SEPARATE_THREAD
)
@SkipAfterFirstFailedTest(TestConstants.SKIP_AFTER_FIRST_FAILED_TEST)
public class OneDimensionalArrayStuffTest {
/**
* Tests the {@link OneDimensionalArrayStuff#push(int[], int)} method.
*
* @param params The {@link JsonParameterSet} to use for the test.
* @param lastOnly Whether to only test the last element.
* @param unchangedOnly Whether to only test that the input array is unchanged. Will not test the result.
*/
private static void testPush(final JsonParameterSet params, final boolean lastOnly, final boolean unchangedOnly) {
final List<Integer> input = params.get("array");
final int value = params.getInt("value");
final List<Integer> expectedArray = params.get("expected result");
final var ParamsContext = params.toContext();
final var cb = contextBuilder()
.add(ParamsContext)
.add("Method", "push");
final int[] inputArray = input.stream().mapToInt(i -> i).toArray();
final int[] result = Assertions2.callObject(
() -> OneDimensionalArrayStuff.push(
inputArray,
value
),
cb.build(),
r -> "An error occurred during execution."
);
final var actualArray = Arrays.stream(result).boxed().toList();
cb.add("actual result", actualArray);
if (unchangedOnly) {
Assertions2.assertIterableEquals(
input,
Arrays.stream(inputArray).boxed().toList(),
cb.build(),
r -> "The input array was changed."
);
return;
}
if (lastOnly) {
Assertions2.assertEquals(
expectedArray.get(expectedArray.size() - 1),
actualArray.get(actualArray.size() - 1),
cb.build(),
r -> "Invalid result."
);
} else {
Assertions2.assertIterableEquals(
expectedArray,
actualArray,
cb.build(),
r -> "Invalid result."
);
}
}
private static void testCalculateNextFibonacci(final JsonParameterSet params, final boolean vanforderung) {
try (final var odasMock = Mockito.mockStatic(OneDimensionalArrayStuff.class, Answers.CALLS_REAL_METHODS)) {
final List<Integer> input = params.get("array");
final List<Integer> expectedArray = params.get("expected result");
final var ParamsContext = params.toContext();
final var cb = contextBuilder()
.add(ParamsContext)
.add("Method", "calculateNextFibonacci");
odasMock.when(() -> OneDimensionalArrayStuff.push(Mockito.any(), Mockito.anyInt())).thenAnswer(invocation -> {
final int[] array = invocation.getArgument(0);
final int value = invocation.getArgument(1);
final int[] newArray = Arrays.copyOf(array, array.length + 1);
newArray[array.length] = value;
return newArray;
});
final int[] inputArray = input.stream().mapToInt(i -> i).toArray();
final int[] result = Assertions2.callObject(
() -> OneDimensionalArrayStuff.calculateNextFibonacci(
inputArray
),
cb.build(),
r -> "An error occurred during execution."
);
final var actualArray = Arrays.stream(result).boxed().toList();
cb.add("actual result", actualArray);
if (vanforderung) {
Assertions2.assertIterableEquals(
input,
Arrays.stream(inputArray).boxed().toList(),
cb.build(),
r -> "The input array was changed."
);
odasMock.verify(
() -> OneDimensionalArrayStuff.push(
inputArray,
expectedArray.get(expectedArray.size() - 1)
),
Mockito.atLeastOnce()
);
return;
}
Assertions2.assertIterableEquals(
expectedArray,
actualArray,
cb.build(),
r -> "Invalid result."
);
}
}
private static void testFibonacci(final JsonParameterSet params, final boolean vanforderung) {
try (final var odasMock = Mockito.mockStatic(OneDimensionalArrayStuff.class, Answers.CALLS_REAL_METHODS)) {
final Integer input = params.get("n");
final int expectedresult = params.get("expected result");
final List<Integer> referenceArray = params.get("reference array");
final var ParamsContext = params.toContext("reference array");
final var cb = contextBuilder()
.add(ParamsContext)
.add("Method", "fibonacci");
odasMock.when(() -> OneDimensionalArrayStuff.push(Mockito.any(), Mockito.anyInt())).thenAnswer(invocation -> {
final int[] array = invocation.getArgument(0);
final int value = invocation.getArgument(1);
final int[] newArray = Arrays.copyOf(array, array.length + 1);
newArray[array.length] = value;
return newArray;
});
odasMock.when(() -> OneDimensionalArrayStuff.calculateNextFibonacci(Mockito.any())).thenAnswer(invocation -> {
final int[] array = invocation.getArgument(0);
return OneDimensionalArrayStuff.push(array, array[array.length - 1] + array[array.length - 2]);
});
final int result = Assertions2.callObject(
() -> OneDimensionalArrayStuff.fibonacci(
input
),
cb.build(),
r -> "An error occurred during execution."
);
cb.add("actual result", result);
if (vanforderung) {
// test calculateFib was used
for (int i = 2; i < referenceArray.size(); i++) {
final int finalI = i;
try {
// test for entire array
odasMock.verify(
() -> OneDimensionalArrayStuff.calculateNextFibonacci(
referenceArray.subList(0, finalI).stream().mapToInt(j -> j).toArray()
),
Mockito.atLeastOnce()
);
} catch (final MockitoException e) {
// test for last two elements
odasMock.verify(
() -> OneDimensionalArrayStuff.calculateNextFibonacci(
referenceArray.subList(finalI - 2, finalI).stream().mapToInt(j -> j).toArray()
),
Mockito.atLeastOnce()
);
}
}
return;
}
Assertions2.assertEquals(
expectedresult,
result,
cb.build(),
r -> "Invalid result."
);
}
}
@ParameterizedTest
@JsonParameterSetTest(value = "OneDimensionalArrayStuffTestPushRandomNumbers.generated.json")
public void testPushLastElementCorrect(final JsonParameterSet params) {
testPush(params, true, false);
}
@ParameterizedTest
@JsonParameterSetTest(value = "OneDimensionalArrayStuffTestPushRandomNumbers.generated.json")
public void testPushAllElementsCorrect(final JsonParameterSet params) {
testPush(params, false, false);
}
@ParameterizedTest
@JsonParameterSetTest(value = "OneDimensionalArrayStuffTestPushRandomNumbers.generated.json")
public void testPushOriginalArrayUnchanged(final JsonParameterSet params) {
testPush(params, false, true);
}
@ParameterizedTest
@JsonParameterSetTest(value = "OneDimensionalArrayStuffTestCalculateNextFibonacciRandomNumbersTwoPositiveNumbersOnly.generated.json")
public void testCalculateNextFibonacciPositiveOnly(final JsonParameterSet params) {
testCalculateNextFibonacci(params, false);
}
@ParameterizedTest
@JsonParameterSetTest(value = "OneDimensionalArrayStuffTestCalculateNextFibonacciRandomNumbers.generated.json")
public void testCalculateNextFibonacciAllNumbers(final JsonParameterSet params) {
testCalculateNextFibonacci(params, false);
}
@ParameterizedTest
@JsonParameterSetTest(value = "OneDimensionalArrayStuffTestCalculateNextFibonacciRandomNumbers.generated.json")
public void testCalculateNextFibonacciVanforderungen(final JsonParameterSet params) {
testCalculateNextFibonacci(params, true);
}
@ParameterizedTest
@JsonParameterSetTest(value = "OneDimensionalArrayStuffTestFibonacciRandomNumbers.generated.json")
public void testFibonacciVanforderungen(final JsonParameterSet params) {
testFibonacci(params, true);
}
@Test
public void testFibonacciNonIterativeVanforderungen() throws NoSuchMethodException {
// test exactly one for loop
final var ml = BasicMethodLink.of(OneDimensionalArrayStuff.class.getDeclaredMethod("fibonacci", int.class));
final var ctElement = ml.getCtElement();
final var cb = contextBuilder()
.add("Method", "fibonacci");
Assertions4.assertIsNotRecursively(
ctElement,
cb.build(),
r -> "The method should not have any recursive calls."
);
final var forLoops = ctElement.filterChildren(
c -> c instanceof spoon.reflect.code.CtFor
|| c instanceof spoon.reflect.code.CtForEach
|| c instanceof spoon.reflect.code.CtWhile
|| c instanceof spoon.reflect.code.CtDo
).list();
Assertions2.assertEquals(
1,
forLoops.size(),
cb.build(),
r -> "The method should contain exactly one for loop."
);
// test exactly one variable declaration
final var variableDeclarations = ctElement.filterChildren(
c -> c instanceof CtLocalVariable<?>
).list(CtLocalVariable.class);
cb.add("variable declarations", variableDeclarations);
Assertions2.assertEquals(
2,
variableDeclarations.size(),
cb.build(),
r -> "The method should contain exactly two variable declarations."
);
// one of type int[] and one of type int
Assertions2.assertTrue(
variableDeclarations.stream().anyMatch(
c -> c.getType().toString().equals("int[]")
),
cb.build(),
r -> "The method should declare exactly one variable of type int[]."
);
Assertions2.assertTrue(
variableDeclarations.stream().anyMatch(
c -> c.getType().toString().equals("int")
),
cb.build(),
r -> "The method should contain exactly one variable of type int."
);
// test no Method calls except for calculateNextFibonacci
final var methodCalls = ctElement.filterChildren(
c -> c instanceof spoon.reflect.code.CtInvocation<?>
).list(CtInvocation.class);
cb.add("method calls", methodCalls);
Assertions2.assertEquals(
1,
methodCalls.size(),
cb.build(),
r -> "The method should contain exactly one method call."
);
final var methodCall = methodCalls.get(0);
Assertions2.assertEquals(
"calculateNextFibonacci",
methodCall.getExecutable().getSimpleName(),
cb.build(),
r -> "The method should only call calculateNextFibonacci."
);
}
@ParameterizedTest
@JsonParameterSetTest(value = "OneDimensionalArrayStuffTestFibonacciRandomNumbersSmallerThanTwo.generated.json")
public void testFibonacciSmallerThanTwo(final JsonParameterSet params) {
testFibonacci(params, false);
}
@ParameterizedTest
@JsonParameterSetTest(value = "OneDimensionalArrayStuffTestFibonacciRandomNumbers.generated.json")
public void testFibonacciBigNumbers(final JsonParameterSet params) {
testFibonacci(params, false);
}
}

64
solution/H02/src/graderPrivate/java/h02/SubmissionTransformer.java Normal file
View file

@ -0,0 +1,64 @@
package h02;
import org.objectweb.asm.*;
import org.sourcegrade.jagr.api.testing.ClassTransformer;
import static org.objectweb.asm.Opcodes.*;
public class SubmissionTransformer implements ClassTransformer {
@Override
public String getName() {
return "MethodInjectingTransformer";
}
@Override
public void transform(ClassReader reader, ClassWriter writer) {
if (reader.getClassName().equals("h02/FourWins")) {
reader.accept(new FourWinsClassVisitor(writer), 0);
} else {
reader.accept(writer, 0);
}
}
private static class FourWinsClassVisitor extends ClassVisitor {
private FourWinsClassVisitor(ClassWriter classWriter) {
super(Opcodes.ASM9, classWriter);
}
@Override
public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
return new MethodVisitor(api, super.visitMethod(access, name, descriptor, signature, exceptions)) {
@Override
public void visitMethodInsn(int opcode, String owner, String name, String descriptor, boolean isInterface) {
if (owner.equals("h02/template/InputHandler") && name.equals("install") && descriptor.equals("()V")) {
super.visitInsn(POP);
} else {
super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
}
}
};
}
@Override
public void visitEnd() {
Label startLabel = new Label();
Label endLabel = new Label();
MethodVisitor mv = super.visitMethod(ACC_PUBLIC,
"getInputHandler",
"()Lh02/template/InputHandler;",
null,
null);
mv.visitLabel(startLabel);
mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, "h02/FourWins", "inputHandler", "Lh02/template/InputHandler;");
mv.visitInsn(ARETURN);
mv.visitLabel(endLabel);
mv.visitLocalVariable("this", "Lh02/FourWins;", null, startLabel, endLabel, 0);
mv.visitMaxs(1, 1);
super.visitEnd();
}
}
}

154
solution/H02/src/graderPrivate/java/h02/TemplateAnnotationProcessor.java Normal file
View file

@ -0,0 +1,154 @@
package h02;
import org.junit.jupiter.api.Test;
import org.tudalgo.algoutils.student.annotation.SolutionOnly;
import org.tudalgo.algoutils.student.annotation.StudentCreationRequired;
import org.tudalgo.algoutils.student.annotation.StudentImplementationRequired;
import org.tudalgo.algoutils.tutor.general.reflections.BasicPackageLink;
import org.tudalgo.algoutils.tutor.general.reflections.BasicTypeLink;
import org.tudalgo.algoutils.tutor.general.reflections.TypeLink;
import spoon.Launcher;
import spoon.reflect.CtModel;
import spoon.reflect.code.CtCodeSnippetStatement;
import spoon.reflect.declaration.CtAnnotation;
import spoon.reflect.declaration.CtElement;
import spoon.reflect.declaration.CtMethod;
import spoon.reflect.declaration.CtRecord;
import spoon.reflect.factory.Factory;
import spoon.support.sniper.SniperJavaPrettyPrinter;
import java.io.File;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;
import static org.tudalgo.algoutils.tutor.general.ResourceUtils.toPathString;
public class TemplateAnnotationProcessor {
private static Launcher createSpoonLauncher(final boolean sniper) {
final Launcher spoon = new Launcher();
spoon.getEnvironment().setAutoImports(true);
spoon.getEnvironment().setComplianceLevel(17);
spoon.getEnvironment().setNoClasspath(true);
spoon.getEnvironment().setCommentEnabled(true);
spoon.getEnvironment().setIgnoreSyntaxErrors(true);
if (sniper) {
spoon.getEnvironment().setPrettyPrinterCreator(
() -> new SniperJavaPrettyPrinter(spoon.getEnvironment())
);
}
return spoon;
}
@Test
public void execute() {
// final Collection<BasicTypeLink> types = List.of(BasicTypeLink.of(TestClass.class));
final Collection<BasicTypeLink> types = BasicPackageLink.of("h02", true).getTypes();
Path tmpDir = null;
try {
tmpDir = Files.createTempDirectory("spoon_output");
System.out.println("tmpdir: " + tmpDir.toString());
for (final BasicTypeLink type : types) {
if (type.reflection().getName().contains("TemplateAnnotationProcessor") || type.reflection().getName().contains("TestClass")) {
continue;
}
System.out.println("processing " + type.name());
final AtomicBoolean modified = new AtomicBoolean(false);
Launcher spoon = createSpoonLauncher(true);
spoon.addInputResource(getFilePath(type).toString());
CtModel model = spoon.buildModel();
var spoonClass = model.getAllTypes().stream().filter(it -> it.getQualifiedName().equals(type.reflection().getName())).findFirst().orElse(null);
if (spoonClass == null || spoonClass instanceof CtRecord) {
// workaround for records because spoon hates them
spoon = createSpoonLauncher(false);
spoon.addInputResource(getFilePath(type).toString());
model = spoon.buildModel();
spoonClass = model.getAllTypes().stream().filter(it -> it.getQualifiedName().equals(type.reflection().getName())).findFirst().orElseThrow();
}
final Factory factory = spoon.getFactory();
processAnnotation(spoonClass, StudentImplementationRequired.class, element -> {
// get annotation text
final var exercise = element.getAnnotation(StudentImplementationRequired.class).value();
if (element instanceof final CtMethod<?> method) {
modified.set(true);
// Create a new code snippet statement with the desired code
String optionalReturn = "";
if (!method.getType().getSimpleName().equals("void")) {
optionalReturn = "return ";
}
final CtCodeSnippetStatement snippet = method.getFactory().Code().createCodeSnippetStatement("// TODO: " + exercise + "\n" + optionalReturn + "org.tudalgo.algoutils.student.Student.crash(\"" + exercise + " - Remove if implemented\")");
// Set the code snippet as the body of the method
method.setBody(snippet);
}
});
processAnnotation(spoonClass, Set.of(SolutionOnly.class, StudentCreationRequired.class), element -> {
if (element instanceof final CtMethod<?> method) {
modified.set(true);
// remove annotations
method.getAnnotations().forEach(CtAnnotation::delete);
// remove method
method.delete();
}
});
if (!modified.get()) {
continue;
}
// Save the modified class
spoon.getEnvironment().setSourceOutputDirectory(new File(tmpDir.toString()));
// overwrite the file if it already exists
// spoon.getEnvironment().setAutoImports(true);
spoon.prettyprint();
final var path = getFilePath(type);
final var outputPath = Path.of(tmpDir.toString(), toPathString(type.reflection().getName()));
Files.deleteIfExists(path);
Files.move(outputPath, path);
}
} catch (final IOException e) {
throw new RuntimeException(e);
} finally {
try (final var walk = Files.walk(tmpDir)) {
walk.sorted(Comparator.reverseOrder()).map(Path::toFile).forEach(File::delete);
} catch (final IOException e) {
throw new RuntimeException("Could not delete tmp dir", e);
}
}
}
public static Path getFilePath(final TypeLink type) {
final String pathString = toPathString(type.reflection().getName());
// find the file
try (final var walk = Files.walk(Path.of("."))) {
return walk.filter(p -> p.endsWith(pathString)).findFirst().orElseThrow();
} catch (final IOException e) {
throw new RuntimeException("an error occurred while reading a source files ", e);
}
}
public static void processAnnotation(
final CtElement root, final Set<Class<? extends Annotation>> annotations,
final Consumer<CtElement> consumer
) {
CtElement element = root.filterChildren(c -> annotations.stream().anyMatch(c::hasAnnotation)).first();
final Set<CtElement> processed = new HashSet<>();
while (element != null && !processed.contains(element)) {
consumer.accept(element);
processed.add(element);
element = root.filterChildren(c -> !processed.contains(c) && annotations.stream().anyMatch(c::hasAnnotation)).first();
}
}
public static void processAnnotation(
final CtElement root, final Class<? extends Annotation> annotation,
final Consumer<CtElement> consumer
) {
processAnnotation(root, Set.of(annotation), consumer);
}
}

19
solution/H02/src/graderPrivate/java/h02/TestConstants.java Normal file
View file

@ -0,0 +1,19 @@
package h02;
import java.util.concurrent.ThreadLocalRandom;
public class TestConstants {
public static long RANDOM_SEED = ThreadLocalRandom.current().nextLong();
public static final boolean SHOW_WORLD = java.lang.management.ManagementFactory
.getRuntimeMXBean()
.getInputArguments()
.toString()
.contains("-agentlib:jdwp"); // true if debugger is attached
public static final int WORLD_DELAY = 500;
public static final int TEST_TIMEOUT_IN_SECONDS = 10;
public static final int TEST_ITERATIONS = 30;
public static final boolean SKIP_AFTER_FIRST_FAILED_TEST = true;
}

267
solution/H02/src/graderPrivate/java/h02/TestJsonGenerators.java Normal file
View file

@ -0,0 +1,267 @@
package h02;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import fopbot.RobotFamily;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.DisabledIf;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static h02.TestConstants.TEST_ITERATIONS;
@DisabledIf("org.tudalgo.algoutils.tutor.general.Utils#isJagrRun()")
public class TestJsonGenerators {
@Test
public void generateOneDimensionalArrayStuffTestPushRandomNumbers() throws IOException {
TestUtils.generateJsonTestData(
(mapper, index, rnd) -> {
final ObjectNode objectNode = mapper.createObjectNode();
objectNode.put("value", rnd.nextInt((int) -2e5, (int) 2e5));
final List<Integer> input = new ArrayList<>();
if (index < 99) {
for (int i = 0; i < rnd.nextInt(5, 10); i++) {
input.add(rnd.nextInt((int) -2e5, (int) 2e5));
}
}
final ArrayNode inputArrayNode = mapper.createArrayNode();
input.forEach(inputArrayNode::add);
objectNode.set("array", inputArrayNode);
input.add(objectNode.get("value").asInt());
final ArrayNode expectedArrayNode = mapper.createArrayNode();
input.forEach(expectedArrayNode::add);
objectNode.set("expected result", expectedArrayNode);
return objectNode;
},
TEST_ITERATIONS,
"OneDimensionalArrayStuffTestPushRandomNumbers.generated.json"
);
}
@ParameterizedTest
@ValueSource(booleans = {true, false})
public void generateOneDimensionalArrayStuffTestCalculateNextFibonacciRandomNumbers(
final boolean twoPositivesOnly
) throws IOException {
TestUtils.generateJsonTestData(
(mapper, index, rnd) -> {
final ObjectNode objectNode = mapper.createObjectNode();
final List<Integer> input = new ArrayList<>();
for (int i = 0; i < (twoPositivesOnly ? 2 : rnd.nextInt(5, 10)); i++) {
input.add(rnd.nextInt(
twoPositivesOnly ? 0 : (int) -2e5,
(int) 2e5
));
}
final ArrayNode inputArrayNode = mapper.createArrayNode();
input.forEach(inputArrayNode::add);
objectNode.set("array", inputArrayNode);
System.out.println(input.size());
final int nextFibonacci = input.get(input.size() - 1) + input.get(input.size() - 2);
input.add(nextFibonacci);
final ArrayNode expectedArrayNode = mapper.createArrayNode();
input.forEach(expectedArrayNode::add);
objectNode.set("expected result", expectedArrayNode);
return objectNode;
},
TEST_ITERATIONS,
"OneDimensionalArrayStuffTestCalculateNextFibonacciRandomNumbers" + (twoPositivesOnly ? "TwoPositiveNumbersOnly" : "") + ".generated.json"
);
}
/**
* Reference Fibonacci implementation using the closed-form formula.
*
* @param n The number to calculate the Fibonacci number for.
* @return The Fibonacci number.
* @see <a href="https://en.wikipedia.org/wiki/Fibonacci_sequence#Closed-form_expression">Fibonacci Closed-form expression on Wikipedia</a>
*/
public static long fib(final int n) {
final double sqrt5 = Math.sqrt(5);
final double phi = (1 + sqrt5) / 2;
final double psi = (1 - sqrt5) / 2;
return Math.round((Math.pow(phi, n) - Math.pow(psi, n)) / sqrt5);
}
@ParameterizedTest
@ValueSource(booleans = {true, false})
public void generateOneDimensionalArrayStuffTestFibonacciRandomNumbers(
final boolean smallerThanTwo
) throws IOException {
TestUtils.generateJsonTestData(
(mapper, index, rnd) -> {
final int startIdx = smallerThanTwo ? index : index + 2;
final ObjectNode objectNode = mapper.createObjectNode();
objectNode.put("n", startIdx);
objectNode.put("expected result", fib(startIdx));
final ArrayNode refArrayNode = mapper.createArrayNode();
for (int i = 0; i <= startIdx; i++) {
refArrayNode.add(fib(i));
}
objectNode.set("reference array", refArrayNode);
return objectNode;
},
smallerThanTwo ? 2 : TEST_ITERATIONS,
"OneDimensionalArrayStuffTestFibonacciRandomNumbers" + (smallerThanTwo ? "SmallerThanTwo" : "") + ".generated.json"
);
}
@Test
public void generateValidateInputRandomCases() throws IOException {
TestUtils.generateJsonTestData(
(mapper, index, rnd) -> {
final ObjectNode objectNode = mapper.createObjectNode();
// Spielfeldgröße zufällig wählen
final int width = rnd.nextInt(3, 10); // Breite zwischen 3 und 10
final int height = rnd.nextInt(3, 10); // Höhe zwischen 3 und 10
objectNode.put("width", width);
objectNode.put("height", height);
// Zufälliges Spielfeld generieren
RobotFamily[][] stones = new RobotFamily[height][width];
for (int row = 0; row < height; row++) {
for (int col = 0; col < width; col++) {
if (rnd.nextBoolean()) {
stones[row][col] = rnd.nextBoolean() ? RobotFamily.SQUARE_RED : RobotFamily.SQUARE_BLUE;
}
}
}
// Spaltenindex zufällig wählen (auch ungültige Indizes)
final int column = rnd.nextInt(-1, width + 1);
objectNode.put("column", column);
// Erwartetes Ergebnis berechnen
boolean expectedResult = column >= 0 && column < width && stones[height - 1][column] == null;
objectNode.put("expected result", expectedResult);
// Spielfeld in JSON-Format umwandeln
ArrayNode stonesArray = mapper.createArrayNode();
for (int row = 0; row < height; row++) {
ArrayNode rowArray = mapper.createArrayNode();
for (int col = 0; col < width; col++) {
if (stones[row][col] == null) {
rowArray.add("EMPTY");
} else if (stones[row][col] == RobotFamily.SQUARE_RED) {
rowArray.add("SQUARE_RED");
} else {
rowArray.add("SQUARE_BLUE");
}
}
stonesArray.add(rowArray);
}
objectNode.set("stones", stonesArray);
return objectNode;
},
TEST_ITERATIONS,
"FourWinsTestValidateInputRandomCases.generated.json"
);
}
@Test
public void generateFourWinsTestGameBoard() throws IOException {
TestUtils.generateJsonTestData(
(mapper, index, rnd) -> {
int worldHeight = rnd.nextInt(5, 10);
int worldWidth = rnd.nextInt(5, 10);
// SQUARE_RED <-> true, SQUARE_BLUE <-> false, null <-> null
RobotFamily[][] gameBoard = new RobotFamily[worldHeight][worldWidth];
List<Integer> firstFreeIndex = new ArrayList<>(worldWidth); // values may exceed array index range
for (int col = 0; col < worldWidth; col++) {
int rowsToFill = rnd.nextInt(worldHeight);
for (int row = 0; row <= rowsToFill; row++) {
gameBoard[row][col] = RobotFamily.SQUARE_RED;
}
firstFreeIndex.add(rowsToFill + 1);
}
ArrayNode firstFreeIndexNode = mapper.createArrayNode();
firstFreeIndex.stream()
.map(mapper.getNodeFactory()::numberNode)
.forEach(firstFreeIndexNode::add);
ArrayNode gameBoardNode = mapper.createArrayNode();
Arrays.stream(gameBoard)
.map(gameBoardRow -> Arrays.stream(gameBoardRow)
.map(rf -> mapper.getNodeFactory().textNode(rf != null ? rf.getName() : null))
.toList())
.forEach(gameBoardRow -> gameBoardNode.add(mapper.createArrayNode().addAll(gameBoardRow)));
ObjectNode objectNode = mapper.createObjectNode()
.put("worldHeight", worldHeight)
.put("worldWidth", worldWidth);
objectNode.set("firstFreeIndex", firstFreeIndexNode);
objectNode.set("gameBoard", gameBoardNode);
return objectNode;
},
TEST_ITERATIONS,
"FourWinsTestGameBoard.generated.json"
);
}
@ParameterizedTest
@ValueSource(booleans = {true, false})
public void generateFourWinsTestGameBoardWin(boolean horizontal) throws IOException {
TestUtils.generateJsonTestData(
(mapper, index, rnd) -> {
int worldHeight = rnd.nextInt(5, 10);
int worldWidth = rnd.nextInt(5, 10);
RobotFamily currentPlayer = rnd.nextBoolean() ? RobotFamily.SQUARE_RED : RobotFamily.SQUARE_BLUE;
ObjectNode objectNode = mapper.createObjectNode()
.put("worldHeight", worldHeight)
.put("worldWidth", worldWidth)
.put("currentPlayer", currentPlayer.getName());
ArrayNode winningCoordinates = mapper.createArrayNode();
rnd.ints(rnd.nextInt(3), 0, horizontal ? worldHeight : worldWidth)
.distinct()
.forEach(i -> {
if (horizontal) {
winningCoordinates.add(mapper.createObjectNode()
.put("x", rnd.nextInt(worldWidth - 4 + 1))
.put("y", i));
} else {
winningCoordinates.add(mapper.createObjectNode()
.put("x", i)
.put("y", rnd.nextInt(worldHeight - 4 + 1)));
}
});
objectNode.set(horizontal ? "winningRowCoordinates" : "winningColCoordinates", winningCoordinates);
RobotFamily[][] gameBoard = new RobotFamily[worldHeight][worldWidth];
for (JsonNode node : winningCoordinates) {
for (int offset = 0; offset < 4; offset++) {
if (horizontal) {
gameBoard[node.get("y").intValue()][node.get("x").intValue() + offset] = currentPlayer;
} else {
gameBoard[node.get("y").intValue() + offset][node.get("x").intValue()] = currentPlayer;
}
}
}
ArrayNode gameBoardNode = mapper.createArrayNode();
Arrays.stream(gameBoard)
.map(gameBoardRow -> Arrays.stream(gameBoardRow)
.map(rf -> mapper.getNodeFactory().textNode(rf != null ? rf.getName() : null))
.toList())
.forEach(gameBoardRow -> gameBoardNode.add(mapper.createArrayNode().addAll(gameBoardRow)));
objectNode.set("gameBoard", gameBoardNode);
return objectNode;
},
TEST_ITERATIONS,
"FourWinsTestGameBoard" + (horizontal ? "Horizontal" : "Vertical") + "Win.generated.json"
);
}
}

110
solution/H02/src/graderPrivate/java/h02/TestUtils.java Normal file
View file

@ -0,0 +1,110 @@
package h02;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.tudalgo.algoutils.tutor.general.SpoonUtils;
import spoon.reflect.declaration.CtElement;
import spoon.reflect.declaration.CtMethod;
import spoon.reflect.declaration.CtParameter;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.function.Consumer;
import static h02.TestConstants.RANDOM_SEED;
public abstract class TestUtils {
/**
* A generator for JSON test data.
*/
public interface JsonGenerator {
/**
* Generates a JSON object node.
*
* @param mapper The object mapper to use.
* @param index The index of the object node.
* @param rnd The random number generator to use.
* @return The generated JSON object node.
*/
ObjectNode generateJson(ObjectMapper mapper, int index, Random rnd);
}
/**
* Generates and saves JSON test data.
*
* @param generator The generator to use.
* @param amount The amount of test data to generate.
* @param fileName The file name to save the test data to.
* @throws IOException If an I/O error occurs.
*/
public static void generateJsonTestData(final JsonGenerator generator, final int amount, final String fileName) throws IOException {
final var seed = RANDOM_SEED;
final var random = new java.util.Random(seed);
final ObjectMapper mapper = new ObjectMapper();
final ArrayNode arrayNode = mapper.createArrayNode();
System.out.println("Generating test data with seed: " + seed);
for (int i = 0; i < amount; i++) {
arrayNode.add(generator.generateJson(mapper, i, random));
}
// convert `ObjectNode` to pretty-print JSON
// System.out.println(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(arrayNode));
final var path = Paths.get(
"src",
"graderPrivate",
"resources",
"h02",
fileName
).toAbsolutePath();
System.out.printf("Saving to file: %s%n", path);
final var file = path.toFile();
file.createNewFile();
mapper.writerWithDefaultPrettyPrinter().writeValue(file, arrayNode);
}
/**
* Returns the Spoon representation of the given method.
*
* @param clazz the method's owner
* @param methodName the method name
* @param paramTypes the method's formal parameter types, if any
* @return the Spoon representation of the given method
*/
public static CtMethod<?> getCtMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) {
return SpoonUtils.getType(clazz.getName())
.getMethodsByName(methodName)
.stream()
.filter(ctMethod -> {
List<CtParameter<?>> parameters = ctMethod.getParameters();
boolean result = parameters.size() == paramTypes.length;
for (int i = 0; result && i < parameters.size(); i++) {
result = parameters.get(i).getType().getQualifiedName().equals(paramTypes[i].getTypeName());
}
return result;
})
.findAny()
.orElseThrow();
}
/**
* Applies the given consumer to the body and its descendants of the given method.
* See also: {@link #getCtMethod(Class, String, Class[])}.
*
* @param clazz the method's owner
* @param methodName the method name
* @param paramTypes the method's formal parameter types, if any
* @param consumer the consumer to apply
*/
public static void iterateMethodStatements(Class<?> clazz, String methodName, Class<?>[] paramTypes, Consumer<Iterator<CtElement>> consumer) {
Iterator<CtElement> iterator = getCtMethod(clazz, methodName, paramTypes)
.getBody()
.descendantIterator();
consumer.accept(iterator);
}
}

104
solution/H02/src/graderPrivate/java/h02/TwoDimensionalArrayStuffTest.java Normal file
View file

@ -0,0 +1,104 @@
package h02;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.params.ParameterizedTest;
import org.sourcegrade.jagr.api.rubric.TestForSubmission;
import org.tudalgo.algoutils.tutor.general.annotation.SkipAfterFirstFailedTest;
import org.tudalgo.algoutils.tutor.general.assertions.Context;
import org.tudalgo.algoutils.tutor.general.json.JsonParameterSet;
import org.tudalgo.algoutils.tutor.general.json.JsonParameterSetTest;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.assertEquals;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.assertNotNull;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.callObject;
import static org.tudalgo.algoutils.tutor.general.assertions.Assertions2.contextBuilder;
@TestForSubmission
@Timeout(
value = TestConstants.TEST_TIMEOUT_IN_SECONDS,
unit = TimeUnit.SECONDS,
threadMode = Timeout.ThreadMode.SEPARATE_THREAD
)
@SkipAfterFirstFailedTest(TestConstants.SKIP_AFTER_FIRST_FAILED_TEST)
public class TwoDimensionalArrayStuffTest {
@ParameterizedTest
@JsonParameterSetTest("TwoDimensionalArrayStuffTestEmptySentence.json")
public void testOccurrencesEmptyArray(JsonParameterSet params) {
testOccurrences(params);
}
@ParameterizedTest
@JsonParameterSetTest("TwoDimensionalArrayStuffTestSingleSentence.json")
public void testOccurrencesSingleSentence(JsonParameterSet params) {
testOccurrences(params);
}
@ParameterizedTest
@JsonParameterSetTest("TwoDimensionalArrayStuffTestMultipleSentences.json")
public void testOccurrencesMultipleSentences(JsonParameterSet params) {
testOccurrences(params);
}
@ParameterizedTest
@JsonParameterSetTest("TwoDimensionalArrayStuffTestIntegerMean.json")
public void testMeanInteger(JsonParameterSet params) {
testMean(params);
}
@ParameterizedTest
@JsonParameterSetTest("TwoDimensionalArrayStuffTestFloatMean.json")
public void testMeanFloat(JsonParameterSet params) {
testMean(params);
}
private static void testOccurrences(JsonParameterSet params) {
List<String> sentences = params.get("sentences");
String[][] input = sentences.stream()
.map(s -> s.split(" "))
.toArray(String[][]::new);
String query = params.getString("query");
Context context = contextBuilder()
.add("input", input)
.add("query", query)
.build();
List<Integer> expectedList = params.get("expectedResult");
AtomicInteger counter = new AtomicInteger(0);
int[] expected = new int[expectedList.size()];
expectedList.forEach(i -> expected[counter.getAndIncrement()] = i);
int[] actual = callObject(() -> TwoDimensionalArrayStuff.occurrences(input, query), context, result ->
"An exception occurred while invoking method occurrences");
assertNotNull(actual, context, result ->
"Array returned by method occurrences is null");
assertEquals(input.length, actual.length, context, result ->
"Array returned by method occurrences does not have correct length");
for (int i = 0; i < sentences.size(); i++) {
final int finalI = i;
assertEquals(expected[i], actual[i], context, result ->
"Array returned by method occurrences does not have correct value at index " + finalI);
}
}
private static void testMean(JsonParameterSet params) {
List<Integer> inputList = params.get("input");
AtomicInteger counter = new AtomicInteger(0);
int[] input = new int[inputList.size()];
inputList.forEach(i -> input[counter.getAndIncrement()] = i);
Context context = contextBuilder()
.add("input", input)
.build();
float expected = params.getFloat("expected");
float actual = callObject(() -> TwoDimensionalArrayStuff.mean(input), context, result ->
"An exception occurred while invoking method mean");
// susceptible to rounding errors?
assertEquals(expected, actual, context, result -> "Value returned by method mean is incorrect");
}
}

1
solution/H02/src/graderPrivate/resources/h02/.gitignore vendored Normal file
View file

@ -0,0 +1 @@
*.generated.json

175
solution/H02/src/graderPrivate/resources/h02/FourWinsTestValidateInput.json Normal file
View file

@ -0,0 +1,175 @@
[
{
"column": -1,
"width": 7,
"height": 6,
"stones": [
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"]
],
"expected result": false
},
{
"column": 7,
"width": 7,
"height": 6,
"stones": [
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"]
],
"expected result": false
},
{
"column": 3,
"width": 7,
"height": 6,
"stones": [
["EMPTY", "EMPTY", "EMPTY", "SQUARE_RED", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "SQUARE_BLUE", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"]
],
"expected result": true
},
{
"column": 5,
"width": 7,
"height": 6,
"stones": [
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_RED", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_BLUE", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_RED", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_BLUE", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_RED", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_BLUE", "EMPTY"]
],
"expected result": false
},
{
"column": 2,
"width": 7,
"height": 6,
"stones": [
["EMPTY", "EMPTY", "SQUARE_RED", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "SQUARE_BLUE", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "SQUARE_RED", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"]
],
"expected result": true
},
{
"column": 6,
"width": 7,
"height": 6,
"stones": [
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_BLUE"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_RED"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_BLUE"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_RED"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_BLUE"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_RED"]
],
"expected result": false
},
{
"column": 4,
"width": 7,
"height": 6,
"stones": [
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"]
],
"expected result": true
},
{
"column": 2,
"width": 4,
"height": 4,
"stones": [
["EMPTY", "EMPTY", "SQUARE_RED", "EMPTY"],
["SQUARE_BLUE", "SQUARE_RED", "SQUARE_RED", "EMPTY"],
["SQUARE_RED", "SQUARE_BLUE", "SQUARE_RED", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY"]
],
"expected result": true
},
{
"column": 3,
"width": 4,
"height": 5,
"stones": [
["EMPTY", "EMPTY", "SQUARE_RED", "SQUARE_BLUE"],
["SQUARE_RED", "SQUARE_BLUE", "SQUARE_RED", "SQUARE_RED"],
["SQUARE_BLUE", "SQUARE_RED", "SQUARE_RED", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY"]
],
"expected result": true
},
{
"column": 1,
"width": 5,
"height": 4,
"stones": [
["EMPTY", "EMPTY", "SQUARE_BLUE", "EMPTY", "EMPTY"],
["SQUARE_RED", "SQUARE_RED", "SQUARE_RED", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"]
],
"expected result": true
},
{
"column": 0,
"width": 3,
"height": 3,
"stones": [
["SQUARE_RED", "EMPTY", "EMPTY"],
["SQUARE_BLUE", "EMPTY", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY"]
],
"expected result": true
},
{
"column": 6,
"width": 8,
"height": 5,
"stones": [
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_BLUE", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_RED", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_BLUE", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_RED", "EMPTY"],
["EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "SQUARE_BLUE", "EMPTY"]
],
"expected result": false
},
{
"column": 2,
"width": 8,
"height": 6,
"stones": [
["EMPTY", "EMPTY", "SQUARE_RED", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["SQUARE_BLUE", "SQUARE_RED", "SQUARE_BLUE", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["SQUARE_RED", "SQUARE_BLUE", "SQUARE_RED", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["SQUARE_BLUE", "SQUARE_RED", "SQUARE_BLUE", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["SQUARE_RED", "SQUARE_BLUE", "SQUARE_RED", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"],
["SQUARE_BLUE", "SQUARE_RED", "SQUARE_BLUE", "EMPTY", "EMPTY", "EMPTY", "EMPTY", "EMPTY"]
],
"expected result": false
}
]

7
solution/H02/src/graderPrivate/resources/h02/TwoDimensionalArrayStuffTestEmptySentence.json Normal file
View file

@ -0,0 +1,7 @@
[
{
"sentences": [],
"query": "",
"expectedResult": []
}
]

22
solution/H02/src/graderPrivate/resources/h02/TwoDimensionalArrayStuffTestFloatMean.json Normal file
View file

@ -0,0 +1,22 @@
[
{
"input": [1, 1, 2, 3, 5, 8],
"expected": 3.3333333
},
{
"input": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
"expected": 5.5
},
{
"input": [1, 10, 100, 1000, 10000],
"expected": 2222.2
},
{
"input": [11, 22, 33, 44],
"expected": 27.5
},
{
"input": [5, 10, 15, 20, 25, 30],
"expected": 17.5
}
]

26
solution/H02/src/graderPrivate/resources/h02/TwoDimensionalArrayStuffTestIntegerMean.json Normal file
View file

@ -0,0 +1,26 @@
[
{
"input": [5, 5],
"expected": 5
},
{
"input": [1, 2, 3, 4, 5],
"expected": 3
},
{
"input": [5, 4, 3, 2, 1],
"expected": 3
},
{
"input": [1, 2, 1, 3, 1, 4],
"expected": 2
},
{
"input": [1, 11, 11, 1],
"expected": 6
},
{
"input": [2, 0, 2, 4],
"expected": 2
}
]

39
solution/H02/src/graderPrivate/resources/h02/TwoDimensionalArrayStuffTestMultipleSentences.json Normal file
View file

@ -0,0 +1,39 @@
[
{
"sentences": [
"lorem ipsum dolor sit amet",
"consectetur adipisici elit",
"sed eiusmod tempor incidunt ut labore et dolore magna aliqua"
],
"query": "lorem",
"expectedResult": [1, 0, 0]
},
{
"sentences": [
"lorem ipsum dolor sit amet",
"amet sit dolor ipsum lorem"
],
"query": "amet",
"expectedResult": [1, 1]
},
{
"sentences": [
"lorem lorem lorem",
"lorem lorem",
"lorem",
"lorem lorem",
"lorem lorem lorem"
],
"query": "lorem",
"expectedResult": [3, 2, 1, 2, 3]
},
{
"sentences": [
"Wenn hinter fliegenden Fliegen Fliegen fliegen dann fliegen Fliegen Fliegen nach",
"Fliegers Fritze fängt fliegende Fliegen fliegende Fliegen fängt Flieger Fritze",
"Blaukraut bleibt Blaukraut und Brautkleid bleibt Brautkleid"
],
"query": "Fliegen",
"expectedResult": [4, 2, 0]
}
]

30
solution/H02/src/graderPrivate/resources/h02/TwoDimensionalArrayStuffTestSingleSentence.json Normal file
View file

@ -0,0 +1,30 @@
[
{
"sentences": [
"lorem ipsum dolor sit amet"
],
"query": "lorem",
"expectedResult": [1]
},
{
"sentences": [
"lorem ipsum dolor sit amet"
],
"query": "amet",
"expectedResult": [1]
},
{
"sentences": [
"lorem lorem lorem"
],
"query": "lorem",
"expectedResult": [3]
},
{
"sentences": [
"ipsum ipsum ipsum"
],
"query": "lorem",
"expectedResult": [0]
}
]

388
solution/H02/src/main/java/h02/FourWins.java Normal file
View file

@ -0,0 +1,388 @@
package h02;
import fopbot.Direction;
import fopbot.Robot;
import fopbot.RobotFamily;
import fopbot.World;
import h02.template.InputHandler;
import org.tudalgo.algoutils.student.annotation.DoNotTouch;
import org.tudalgo.algoutils.student.annotation.StudentImplementationRequired;
import java.util.Optional;
/**
* The {@link FourWins} class represents the main class of the FourWins game.
*/
public class FourWins {
private final InputHandler inputHandler = new InputHandler(this);
/**
* The width of the game board.
*/
private final int width;
/**
* The height of the game board.
*/
private final int height;
/**
* Indicates whether the game has finished.
*/
@SuppressWarnings({"FieldMayBeFinal", "FieldCanBeLocal"})
private boolean finished = false;
/**
* Creates a new {@link FourWins} instance with the given width and height.
*
* @param width the width of the game board
* @param height the height of the game board
*/
FourWins(final int width, final int height) {
this.width = width;
this.height = height;
}
/**
* Starts the game by setting up the world and executing the game loop.
*/
void startGame() {
setupWorld();
gameLoop();
}
/**
* Sets up the world and installs the {@link InputHandler}.
*/
void setupWorld() {
World.setSize(width, height);
World.setDelay(10);
World.setVisible(true);
inputHandler.install();
}
/**
* Validates if a given column index is within the bounds of the game board and not fully occupied.
*
* @param column The column index to validate.
* @param stones 2D array representing the game board, where each cell contains a RobotFamily color indicating the
* player that has placed a stone in that position.
* @return true if the column is within bounds and has at least one unoccupied cell; false otherwise.
*/
@StudentImplementationRequired("H2.2.1")
public static boolean validateInput(final int column, final RobotFamily[][] stones) {
return column >= 0 && column < World.getWidth() && stones[World.getHeight() - 1][column] == null;
}
/**
* Calculates the next unoccupied row index in the specified column. This row index is the next destination for a
* falling stone.
*
* @param column The column index where the stone is to be dropped.
* @param stones 2D array representing the game board, where each cell contains a RobotFamily object indicating the
* player that has placed a stone in that position.
* @return Index of the next unoccupied row index in the specified column.
*/
@StudentImplementationRequired("H2.2.2")
public static int getDestinationRow(final int column, final RobotFamily[][] stones) {
for (int row = 0; row < stones.length; row++) {
if (stones[row][column] == null) {
return row;
}
}
return -1;
}
/**
* Drops a stone into the specified column of the game board, simulating a falling animation. This method gets the
* destination row for the stone in the specified column with the `getDestinationRow` method. It creates a new Robot
* instance to represent the stone with the currentPlayer's RobotFamily in the given column and the destination row.
* After that it simulates the stone's fall by decrementing its position until it reaches the destination row. Once
* the stone reaches its destination, the method updates the stones array (a 2D array of RobotFamily colors) to
* mark the slot as occupied by the currentPlayer.
*
* @param column The column index where the stone is to be dropped.
* @param stones 2D array representing the game board, where each cell contains a RobotFamily object
* indicating the player that has placed a stone in that position.
* @param currentPlayer The RobotFamily object representing the current player dropping the stone.
*/
@StudentImplementationRequired("H2.2.2")
public static void dropStone(final int column, final RobotFamily[][] stones, final RobotFamily currentPlayer) {
// spawn stone
final Robot stone = new Robot(column, World.getHeight() - 1, Direction.DOWN, 0, currentPlayer);
// let stone fall
final int row = getDestinationRow(column, stones);
for (int currentRow = World.getHeight() - 1; currentRow > row; currentRow--) {
stone.move();
}
// turn stone up
stone.turnLeft();
stone.turnLeft();
// set slot as occupied
stones[row][column] = currentPlayer;
}
/**
* Checks if the current player has won by any condition. The conditions can be a horizontal, vertical, diagonal, or
* anti-diagonal line of at least four stones.
*
* @param stones 2D array representing the game board, where each cell contains a RobotFamily color
* indicating the player that has placed a stone in that position.
* @param currentPlayer The RobotFamily color representing the current player to check for a win.
* @return true if the current player has formed a horizontal line of at least four stones; false otherwise.
*/
@StudentImplementationRequired("H2.2.3")
public static boolean testWinConditions(final RobotFamily[][] stones, final RobotFamily currentPlayer) {
return testWinVertical(stones, currentPlayer)
|| testWinHorizontal(stones, currentPlayer)
|| testWinDiagonal(stones, currentPlayer);
}
/**
* Checks if the current player has won by forming a horizontal line of at least consecutive four stones.
*
* @param stones 2D array representing the game board, where each cell contains a RobotFamily color
* indicating the player that has placed a stone in that position.
* @param currentPlayer The RobotFamily color representing the current player to check for a win.
* @return true if the current player has formed a horizontal line of at least four stones; false otherwise.
*/
@StudentImplementationRequired("H2.2.3")
public static boolean testWinHorizontal(final RobotFamily[][] stones, final RobotFamily currentPlayer) {
for (int row = 0; row < World.getHeight(); row++) {
int stoneCount = 0;
for (int column = 0; column < World.getWidth(); column++) {
stoneCount = stones[row][column] == currentPlayer ? stoneCount + 1 : 0;
if (stoneCount >= 4) {
return true;
}
}
}
return false;
}
/**
* Checks if the current player has won by forming a vertical line of at least consecutive four stones.
*
* @param stones 2D array representing the game board, where each cell contains a RobotFamily color
* indicating the player that has placed a stone in that position.
* @param currentPlayer The RobotFamily color representing the current player to check for a win.
* @return true if the current player has formed a vertical line of at least four stones; false otherwise.
*/
@StudentImplementationRequired("H2.2.3")
public static boolean testWinVertical(final RobotFamily[][] stones, final RobotFamily currentPlayer) {
for (int column = 0; column < World.getWidth(); column++) {
int stoneCount = 0;
for (int row = 0; row < World.getHeight(); row++) {
stoneCount = stones[row][column] == currentPlayer ? stoneCount + 1 : 0;
if (stoneCount >= 4) {
return true;
}
}
}
return false;
}
/**
* Checks if the current player has won by forming a diagonal line of at least consecutive four stones.
*
* @param stones 2D array representing the game board, where each cell contains a RobotFamily color
* indicating the player that has placed a stone in that position.
* @param currentPlayer The RobotFamily color representing the current player to check for a win.
* @return true if the current player has formed a diagonal line of at least four stones; false otherwise.
*/
@DoNotTouch
public static boolean testWinDiagonal(final RobotFamily[][] stones, final RobotFamily currentPlayer) {
@SuppressWarnings("CheckStyle") final int MAX_STONES = 4;
@SuppressWarnings("CheckStyle") final int WIDTH = World.getWidth();
@SuppressWarnings("CheckStyle") final int HEIGHT = World.getHeight();
int[] direction = new int[]{1, 1};
// for every field
for (int y = 0; y < HEIGHT; y++) {
for (int x = 0; x < WIDTH; x++) {
// for every direction
for (int nthDirection = 0; nthDirection < 4; nthDirection++) {
final int[] pos = {x, y};
// test for consecutive coins
int coinCount = 0; // start counting at 0
while (pos[0] >= 0 && pos[0] < WIDTH
&& pos[1] >= 0 && pos[1] < HEIGHT
&& stones[pos[1]][pos[0]] == currentPlayer) {
coinCount++; // count every stone that has currentPlayer's color
if (coinCount >= MAX_STONES) {
return true;
}
pos[0] += direction[0];
pos[1] += direction[1];
}
direction = new int[]{direction[1], -direction[0]}; // next direction (rotate by 90 deg)
}
}
}
return false;
}
/**
* Switches the player for each turn. If the current player is SQUARE_BLUE, SQUARE_RED is returned as the next
* player. If the current player is SQUARE_RED, SQUARE_BLUE is returned as the next player.
*
* @param currentPlayer The player color of the current player.
* @return The player color of the next player.
*/
@StudentImplementationRequired("H2.2.4")
public static RobotFamily nextPlayer(final RobotFamily currentPlayer) {
return currentPlayer == RobotFamily.SQUARE_BLUE ? RobotFamily.SQUARE_RED : RobotFamily.SQUARE_BLUE;
}
/**
* Displays a Message in the console and on the game board indicating the game is drawn.
*/
@StudentImplementationRequired("H2.2.4")
public void writeDrawMessage() {
inputHandler.displayDrawStatus();
// student implementation here:
System.out.println("No valid columns found. Hence, game ends with a draw.");
}
/**
* Displays a Message in the console and on the game board indicating the game is won by a player.
*
* @param winner {@link RobotFamily} of the winning player
*/
@StudentImplementationRequired("H2.2.4")
public void writeWinnerMessage(final RobotFamily winner) {
inputHandler.displayWinnerStatus(winner);
// student implementation here:
System.out.println("Player " + winner + " wins the game!");
}
/**
* Displays the winner of the game by printing the winning color in the console and filling the whole field with
* Robots of the winning color.
*
* @param winner The RobotFamily color of the winner.
*/
@StudentImplementationRequired("H2.2.4")
public static void colorFieldBackground(final RobotFamily winner) {
for (int x = 0; x < World.getWidth(); x++) {
for (int y = 0; y < World.getHeight(); y++) {
setFieldColor(x, y, winner);
}
}
}
/**
* Executes the main game loop, handling player turns, stone drops, and win condition checks. This method
* initializes the game board as a 2D array of RobotFamily colors, representing the slots that can be filled with
* players' stones. It starts with a predefined currentPlayer and continues in a loop until a win condition is met.
* Each iteration of the loop waits for player input to select a column to drop a stone into, switches the current
* player, drops the stone in the selected column, and checks for win conditions. If a win condition is met, the
* loop ends, and the winner is displayed.
*/
@StudentImplementationRequired("H2.2.4")
void gameLoop() {
final RobotFamily[][] stones = new RobotFamily[World.getHeight()][World.getWidth()];
RobotFamily currentPlayer = RobotFamily.SQUARE_BLUE;
boolean draw = false;
finished = false;
while (!finished) {
// student implementation here:
currentPlayer = nextPlayer(currentPlayer);
// wait for click in column (DO NOT TOUCH)
finished = draw = isGameBoardFull(stones);
if (draw) {
break;
}
final int column = inputHandler.getNextInput(currentPlayer, stones);
// student implementation here:
dropStone(column, stones, currentPlayer);
finished = testWinConditions(stones, currentPlayer);
}
// displaying either draw or winner (DO NOT TOUCH)
if (draw) {
writeDrawMessage();
colorFieldBackground(getDrawnRobotFamily());
} else {
writeWinnerMessage(currentPlayer);
colorFieldBackground(currentPlayer);
}
}
/**
* Executes the main game loop, handling player turns, stone drops, and win condition checks. Sets the background
* color of a field at the specified coordinates. The color is derived from the {@link RobotFamily} SQUARE_BLUE or
* SQUARE_RED.
*
* @param x the x coordinate of the field
* @param y the y coordinate of the field
* @param color the {@link RobotFamily} corresponding to the field color to set
*/
@DoNotTouch
public static void setFieldColor(final int x, final int y, final RobotFamily color) {
World.getGlobalWorld().setFieldColor(x, y, color.getColor());
}
/**
* Returns the {@link RobotFamily} which represents a drawn game.
*
* @return the {@link RobotFamily} which represents a drawn game.
*/
@DoNotTouch
@SuppressWarnings("UnstableApiUsage")
protected static RobotFamily getDrawnRobotFamily() {
return Optional.ofNullable(World.getGlobalWorld().getGuiPanel()).filter(guiPanel -> !guiPanel.isDarkMode()).map(guiPanel -> RobotFamily.SQUARE_ORANGE).orElse(RobotFamily.SQUARE_YELLOW);
}
/**
* Checks if all columns of the game board are fully occupied.
*
* @param stones 2D array representing the game board, where each cell contains a RobotFamily
* @return true if all columns of the game board are fully occupied; false otherwise.
*/
@DoNotTouch
public static boolean isGameBoardFull(final RobotFamily[][] stones) {
for (int x = 0; x < World.getWidth(); x++) {
if (FourWins.validateInput(x, stones)) {
return false;
}
}
return true;
}
/**
* Returns this instance's {@link InputHandler}.
*
* @return the input handler
*/
@DoNotTouch
public InputHandler getInputHandler() {
return inputHandler;
}
/**
* Returns {@code true} when the game is finished, {@code false} otherwise.
*
* @return whether the game is finished.
*/
public boolean isFinished() {
return finished;
}
}

218
solution/H02/src/main/java/h02/Main.java Normal file
View file

@ -0,0 +1,218 @@
package h02;
import fopbot.RobotFamily;
import fopbot.World;
import org.tudalgo.algoutils.student.annotation.SolutionOnly;
import org.tudalgo.algoutils.student.annotation.StudentImplementationRequired;
import static org.tudalgo.algoutils.student.io.PropertyUtils.getIntProperty;
import static org.tudalgo.algoutils.student.test.StudentTestUtils.printTestResults;
import static org.tudalgo.algoutils.student.test.StudentTestUtils.testEquals;
/**
* Main entry point in executing the program.
*/
public class Main {
/**
* Main entry point in executing the program.
*
* @param args program arguments, currently ignored
*/
public static void main(final String[] args) {
// H1
sanityChecksH211();
sanityChecksH212();
printTestResults();
// H2
sanityChecksH22();
printTestResults();
// starting game (comment out if you just want to run the tests)
final var propFile = "h02.properties";
new FourWins(
getIntProperty(propFile, "FW_WORLD_WIDTH"),
getIntProperty(propFile, "FW_WORLD_HEIGHT")
).startGame();
}
/**
* Perform sanity checks for exercise H2.1.1.
*/
@StudentImplementationRequired("H2.3")
public static void sanityChecksH211() {
// push test
final int[] newArray = OneDimensionalArrayStuff.push(new int[]{0, 1}, 2);
final int[] expectedArray = {0, 1, 2};
testEquals(expectedArray.length, newArray.length);
for (int i = 0; i < newArray.length; i++) {
testEquals(expectedArray[i], newArray[i]);
}
// calculateNextFibonacci test
int[] fibonacciArray = {0, 1};
for (int i = 0; i < 20; i++) {
fibonacciArray = OneDimensionalArrayStuff.calculateNextFibonacci(fibonacciArray);
}
testEquals(22, fibonacciArray.length);
testEquals(0, fibonacciArray[0]);
testEquals(1, fibonacciArray[1]);
for (int i = 2; i < fibonacciArray.length; i++) {
testEquals(fibonacciArray[i - 1] + fibonacciArray[i - 2], fibonacciArray[i]);
}
// fibonacci test
final int[] reference = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34};
for (int i = 0; i < 10; i++) {
testEquals(reference[i], OneDimensionalArrayStuff.fibonacci(i));
}
}
/**
* Perform sanity checks for exercise H2.1.2.
*/
@StudentImplementationRequired("H2.3")
public static void sanityChecksH212() {
// predefined simple test
final String[][] simpleTest = new String[][]{
"a b c d e f".split(" "),
"a b c d e f".split(" "),
"a b c d e f".split(" "),
};
// predefined complex test
final String[][] complexTest = new String[][]{
"a a b b c c".split(" "),
"a b c d e f".split(" "),
"a a a b b b c c c".split(" "),
};
// student implementation here:
sanityChecksH212Helper(
simpleTest,
"b",
new int[]{1, 1, 1},
1
);
sanityChecksH212Helper(
complexTest,
"b",
new int[]{2, 1, 3},
2
);
}
/**
* Helper method for sanity checks for exercise H2.1.2.
*
* @param input the input array
* @param query the query string
* @param refOcc the reference occurrences
* @param refMean the reference mean
*/
@SolutionOnly
public static void sanityChecksH212Helper(
final String[][] input,
final String query,
final int[] refOcc,
final float refMean
) {
final int[] occ = TwoDimensionalArrayStuff.occurrences(input, query);
testEquals(refOcc.length, occ.length);
for (int i = 0; i < occ.length; i++) {
testEquals(refOcc[i], occ[i]);
}
testEquals(refMean, TwoDimensionalArrayStuff.meanOccurrencesPerLine(input, query));
}
/**
* Perform sanity checks for exercise H2.2
*/
@StudentImplementationRequired("H2.4")
public static void sanityChecksH22() {
// setting world size
World.setSize(4, 5);
// predefined stones1 array
final RobotFamily[][] stones1 = {
{null, RobotFamily.SQUARE_BLUE, null, RobotFamily.SQUARE_RED},
{null, null, null, RobotFamily.SQUARE_BLUE},
{null, null, null, RobotFamily.SQUARE_RED},
{null, null, null, RobotFamily.SQUARE_BLUE},
{null, null, null, RobotFamily.SQUARE_RED},
};
// predefined stones2 array
final RobotFamily[][] stones2 = {
{RobotFamily.SQUARE_BLUE, RobotFamily.SQUARE_BLUE, RobotFamily.SQUARE_BLUE, RobotFamily.SQUARE_BLUE},
{RobotFamily.SQUARE_RED, RobotFamily.SQUARE_RED, RobotFamily.SQUARE_BLUE, RobotFamily.SQUARE_RED},
{RobotFamily.SQUARE_BLUE, RobotFamily.SQUARE_RED, RobotFamily.SQUARE_BLUE, RobotFamily.SQUARE_BLUE},
{RobotFamily.SQUARE_BLUE, RobotFamily.SQUARE_RED, RobotFamily.SQUARE_BLUE, RobotFamily.SQUARE_RED},
{RobotFamily.SQUARE_BLUE, RobotFamily.SQUARE_BLUE, RobotFamily.SQUARE_BLUE, RobotFamily.SQUARE_RED},
};
// student implementation here:
// H2.2.1 validateInput
final boolean isInCol1 = FourWins.validateInput(1, stones1);
final boolean isInCol3 = FourWins.validateInput(3, stones1);
testEquals(true, isInCol1);
testEquals(false, isInCol3);
// H2.2.2 getDestinationRow
final int rowCol1 = FourWins.getDestinationRow(1, stones1);
final int rowCol3 = FourWins.getDestinationRow(3, stones1);
testEquals(1, rowCol1);
testEquals(-1, rowCol3);
// H2.2.2 dropStone
FourWins.dropStone(1, stones1, RobotFamily.SQUARE_RED);
// System.out.println(Arrays.deepToString(stones1));
// System.out.println(stones1);
testEquals(RobotFamily.SQUARE_RED, stones1[1][1]);
// H2.2.3 testWinHorizontal
final boolean winRowBlue = FourWins.testWinHorizontal(stones2, RobotFamily.SQUARE_BLUE);
final boolean winRowRed = FourWins.testWinHorizontal(stones2, RobotFamily.SQUARE_RED);
testEquals(true, winRowBlue);
testEquals(false, winRowRed);
// H2.2.3 testWinVertical
final boolean winColStones2 = FourWins.testWinVertical(stones2, RobotFamily.SQUARE_BLUE);
final boolean winColStones1 = FourWins.testWinVertical(stones1, RobotFamily.SQUARE_BLUE);
testEquals(true, winColStones2);
testEquals(false, winColStones1);
// H2.2.3 testWinConditions
final boolean winStones2 = FourWins.testWinConditions(stones2, RobotFamily.SQUARE_BLUE);
final boolean winStones1 = FourWins.testWinConditions(stones1, RobotFamily.SQUARE_BLUE);
testEquals(true, winStones2);
testEquals(false, winStones1);
// H2.2.4 switchPlayer
final RobotFamily nextPlayer1 = FourWins.nextPlayer(RobotFamily.SQUARE_BLUE);
final RobotFamily nextPlayer2 = FourWins.nextPlayer(RobotFamily.SQUARE_RED);
testEquals(RobotFamily.SQUARE_RED, nextPlayer1);
testEquals(RobotFamily.SQUARE_BLUE, nextPlayer2);
// H2.2.4 colorFieldBackground, writeDrawMessage, writeWinnerMessage, gameLoop
// Test by playing
}
}

64
solution/H02/src/main/java/h02/OneDimensionalArrayStuff.java Normal file
View file

@ -0,0 +1,64 @@
package h02;
import org.tudalgo.algoutils.student.annotation.StudentImplementationRequired;
/**
* This class serves as a container for the methods that are to be implemented by the students for exercise H2.1.1.
*/
public class OneDimensionalArrayStuff {
/**
* Prevent instantiation of this utility class.
*/
private OneDimensionalArrayStuff() {
throw new IllegalStateException("This class is not meant to be instantiated.");
}
/**
* Returns a new array that is a copy of the input array with the given value appended at the end.
*
* @param array the input array
* @param value the value to append
* @return a new array that is a copy of the input array with the given value appended at the end
*/
@StudentImplementationRequired("H2.1.1")
public static int[] push(final int[] array, final int value) {
final int[] newArray = new int[array.length + 1];
//noinspection ManualArrayCopy
for (int i = 0; i < array.length; i++) {
newArray[i] = array[i];
}
newArray[array.length] = value;
return newArray;
}
/**
* Calculates the next Fibonacci number based on the given array and returns a new array with the next Fibonacci
* number appended at the end.
*
* @param array the input array containing the last two Fibonacci numbers up to the current point
* @return a new array with the next Fibonacci number appended at the end
*/
@StudentImplementationRequired("H2.1.1")
public static int[] calculateNextFibonacci(final int[] array) {
return push(array, array[array.length - 1] + array[array.length - 2]);
}
/**
* Returns the n-th Fibonacci number.
*
* @param n the index of the Fibonacci number to return
* @return the n-th Fibonacci number
*/
@StudentImplementationRequired("H2.1.1")
public static int fibonacci(final int n) {
if (n < 2) {
return n; // base case (n=0 or n=1)
}
int[] array = {0, 1};
for (int i = 2; i <= n; i++) {
array = calculateNextFibonacci(array);
}
return array[array.length - 1];
}
}

89
solution/H02/src/main/java/h02/TwoDimensionalArrayStuff.java Normal file
View file

@ -0,0 +1,89 @@
package h02;
import org.tudalgo.algoutils.student.annotation.DoNotTouch;
import org.tudalgo.algoutils.student.annotation.StudentImplementationRequired;
import java.util.Arrays;
/**
* This class serves as a container for the methods that are to be implemented by the students for exercise H2.1.2.
*/
public class TwoDimensionalArrayStuff {
/**
* Prevent instantiation of this utility class.
*/
private TwoDimensionalArrayStuff() {
throw new IllegalStateException("This class is not meant to be instantiated.");
}
/**
* Returns an array containing the number of occurrences of the query {@link String} in each line of the input array.
*
* @param input the input array
* @param query the query {@link String}
* @return an array containing the number of occurrences of the query {@link String} in each line of the input array
*/
@StudentImplementationRequired("H2.1.2")
public static int[] occurrences(final String[][] input, final String query) {
final int[] result = new int[input.length];
for (int row = 0; row < input.length; row++) {
for (int col = 0; col < input[row].length; col++) {
if (input[row][col].equals(query)) {
result[row]++;
}
}
}
return result;
}
/**
* Returns the mean of the input array.
*
* @param input the input array
* @return the mean of the input array
*/
@StudentImplementationRequired("H2.1.2")
public static float mean(final int[] input) {
int sum = 0;
for (final int j : input) {
sum += j;
}
return (float) sum / input.length;
}
/**
* Returns the mean number of occurrences of the query {@link String} in each line of the input array.
*
* @param input the input array
* @param query the query {@link String}
* @return the mean number of occurrences of the query {@link String} in each line of the input array
*/
@DoNotTouch
public static float meanOccurrencesPerLine(final String[][] input, final String query) {
return mean(occurrences(input, query));
}
/**
* Overload that splits the input string by lines and spaces, then calls regular meanOccurrencesPerLine.
*
* @param input the input string to split by lines and spaces
* @param query the query {@link String}
* @return the mean number of occurrences of the query {@link String} in each line of the input array
*/
@DoNotTouch
public static float meanOccurrencesPerLine(final String input, final String query) {
// filter out unwanted symbols
final String filteredInput = input.replaceAll("[^\\w\\s]", "");
// split by lines
final var processedInput = Arrays.stream(filteredInput.split("(\\r\\n|\\r|\\n)"))
// split by spaces
.map(line -> line.split("\\s"))
// collect to 2D array
.toArray(String[][]::new);
/// uncomment the following line to log processed input
// System.out.printf("Processed input: %s%n", Arrays.deepToString(processedInput));
// call regular meanOccurrencesPerLine
return meanOccurrencesPerLine(processedInput, query);
}
}

201
solution/H02/src/main/java/h02/template/InputHandler.java Normal file
View file

@ -0,0 +1,201 @@
package h02.template;
import fopbot.RobotFamily;
import fopbot.World;
import h02.FourWins;
import org.tudalgo.algoutils.student.annotation.DoNotTouch;
import javax.swing.*;
import javax.swing.border.EmptyBorder;
import java.awt.*;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.beans.PropertyChangeEvent;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Supplier;
/**
* The {@link InputHandler} handles the input of the users.
*/
@DoNotTouch
public class InputHandler {
/**
* The input queue.
*/
private final BlockingDeque<Integer> inputQueue = new LinkedBlockingDeque<>();
/**
* The {@link FourWins} instance.
*/
private final FourWins fourWins;
/**
* Whether the row select mode is active.
*/
private final AtomicBoolean rowSelectMode = new AtomicBoolean(false);
/**
* The status label.
*/
private final JLabel statusLabel = new JLabel("", SwingConstants.CENTER);
/**
* Creates a new {@link InputHandler} instance.
*
* @param fourWins the {@link FourWins} instance
*/
public InputHandler(final FourWins fourWins) {
this.fourWins = fourWins;
final int padding = 4; // Padding in pixels
statusLabel.setBorder(new EmptyBorder(padding, padding, padding, padding));
}
/**
* Sets the color of the given column to the given color.
*
* @param column the column to set the color of
* @param colorSupplier the color to set
*/
private void setColumnColor(final int column, final Supplier<Color> colorSupplier) {
for (int i = 0; i < World.getHeight(); i++) {
final int finalI = i;
SwingUtilities.invokeLater(() -> World.getGlobalWorld().getField(column, finalI).setFieldColor(colorSupplier));
}
}
/**
* Executes the given action only if the game is running.
*
* @param action the action to execute
*/
private void whenGameIsRunning(final Runnable action) {
if (!fourWins.isFinished()) {
action.run();
}
}
/**
* Installs the input handler to the fopbot world.
*/
@SuppressWarnings("UnstableApiUsage")
public void install() {
final var guiPanel = World.getGlobalWorld().getGuiPanel();
final var guiFrame = World.getGlobalWorld().getGuiFrame();
World.getGlobalWorld().getInputHandler().addFieldClickListener(
e -> whenGameIsRunning(() -> addInput(e.getField().getX()))
);
World.getGlobalWorld().getInputHandler().addFieldHoverListener(e -> whenGameIsRunning(() -> {
// deselect last hovered field, if any
if (e.getPreviousField() != null) {
setColumnColor(e.getPreviousField().getX(), () -> null);
}
if (rowSelectMode.get()) {
// select current hovered field
if (e.getField() != null) {
setColumnColor(
e.getField().getX(),
() -> guiPanel.isDarkMode()
? Color.yellow
: Color.orange
);
}
}
}));
statusLabel.setFont(statusLabel.getFont().deriveFont(guiPanel.scale(20.0f)));
guiFrame.add(statusLabel, BorderLayout.NORTH);
guiFrame.pack();
guiPanel.addDarkModeChangeListener(this::onDarkModeChange);
guiPanel.addComponentListener(new ComponentAdapter() {
@Override
public void componentResized(final ComponentEvent e) {
statusLabel.setFont(
statusLabel.getFont().deriveFont(
Math.max(20f, 0.04f * Math.min(guiPanel.getWidth(), guiPanel.getHeight()))
)
);
}
});
// trigger dark mode change to set the correct color
guiPanel.setDarkMode(World.getGlobalWorld().getGuiPanel().isDarkMode());
}
/**
* Called when the dark mode changes.
*
* @param e the property change event
*/
@SuppressWarnings("UnstableApiUsage")
public void onDarkModeChange(final PropertyChangeEvent e) {
final var darkMode = (boolean) e.getNewValue();
statusLabel.setForeground(darkMode ? Color.white : Color.black);
World.getGlobalWorld().getGuiFrame().getContentPane().setBackground(darkMode ? Color.black : Color.white);
}
/**
* Adds an input to the input queue. When {@link #getNextInput(RobotFamily, RobotFamily[][])} is called, the program
* will wait until this method is called.
*
* @param input the input to add
*/
public void addInput(final int input) {
inputQueue.add(input);
}
/**
* Returns the next input from the input queue. If the input is invalid, the user will be prompted to enter a new
* input. The program will halt until a valid input is entered.
*
* @param currentPlayer the current player
* @param stones the current state of the game board
* @return the next input from the input queue
*/
public int getNextInput(final RobotFamily currentPlayer, final RobotFamily[][] stones) {
rowSelectMode.set(true);
statusLabel.setText(
"<html>Click on a column to insert a disc.<br>Current Player: %s</html>".formatted(currentPlayer.getName())
);
try {
final int input = inputQueue.take();
System.out.println("Received column input: " + input);
if (!FourWins.validateInput(input, stones)) {
System.out.println("Invalid column input, please try again.");
return getNextInput(currentPlayer, stones);
}
rowSelectMode.set(false);
return input;
} catch (final InterruptedException e) {
rowSelectMode.set(false);
throw new RuntimeException(e);
}
}
/**
* Sets a status message, saying that the game has ended in a draw.
*/
public void displayDrawStatus() {
statusLabel.setText("<html>No valid columns found. <br>Hence, game ends with a draw.</html>");
}
/**
* Sets a status message, saying that the game has ended with a winner.
*
* @param winner the winner of the game
*/
public void displayWinnerStatus(final RobotFamily winner) {
statusLabel.setText("<html>Player %s has won the game!</html>".formatted(winner.getName()));
}
/**
* Returns the {@link #statusLabel} of this {@link InputHandler}.
*
* <p>Use the {@link JLabel#getText()} method to get the current text of the label, and the
* {@link JLabel#setText(String)} method to update the text.
*
* @return the {@link #statusLabel} of this {@link InputHandler}
*/
public JLabel getStatusLabel() {
return statusLabel;
}
}

2
solution/H02/src/main/resources/h02.properties Normal file
View file

@ -0,0 +1,2 @@
FW_WORLD_WIDTH = 7
FW_WORLD_HEIGHT = 6

16
solution/H02/src/test/java/h02/ExampleJUnitTest.java Normal file
View file

@ -0,0 +1,16 @@
package h02;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/**
* An example JUnit test class.
*/
public class ExampleJUnitTest {
@Test
public void testAddition() {
assertEquals(2, 1 + 1);
}
}

1
solution/H02/version Normal file
View file

@ -0,0 +1 @@
0.1.0-SNAPSHOT