diff --git a/docs/dev/cypress.rst b/docs/dev/cypress.rst
index 03d4034fc007..c68afc351ec1 100644
--- a/docs/dev/cypress.rst
+++ b/docs/dev/cypress.rst
@@ -51,7 +51,7 @@ Follow these steps to create your local cypress instance:
       "studentGroupName": "students",
       "tutorGroupName": "tutors",
       "editorGroupName": "editors",
-      "instructorGroupName": "instructors"
+      "instructorGroupName": "instructors",
       "createUsers": false
     }
 
diff --git a/docs/user/exams/instructor/add_exercises.png b/docs/user/exams/instructor/add_exercises.png
index 659e08d438a4..223bff5f3c4c 100644
Binary files a/docs/user/exams/instructor/add_exercises.png and b/docs/user/exams/instructor/add_exercises.png differ
diff --git a/docs/user/exams/instructors_guide.rst b/docs/user/exams/instructors_guide.rst
index f7af1bbe3639..069cba54571b 100644
--- a/docs/user/exams/instructors_guide.rst
+++ b/docs/user/exams/instructors_guide.rst
@@ -190,7 +190,10 @@ During the exam creation and configuration, you can create your exam and configu
 
 
     - In the *Configure Grading* screen, you can tweak the ``weight`` of the tests, the ``bonus multiplier`` and add ``bonus points``.
-    - You can hide tests so that they are not executed during the exam conduction. Students can not receive feedback from hidden tests during the exam conduction.
+    - You can hide tests so that they are not executed during the exam conduction by setting the test case visibility to `After Release Date of Results.` Students can not receive feedback from hidden tests during the exam conduction. This option is set by default when creating new programming exercises within an exam.
+
+    .. note::
+        When importing exercises, the test case visibility of imported exercise will equal the visibility of the original exercise. You can adjust the test case visibility in the import `Assessment` section to be set to `After Release Date of Results`.
 
     .. note::
         If you hide all tests, the students will only be able to see if their submission compiles during the conduction. Set the ``Run Tests once after Due Date`` after the
diff --git a/src/main/java/de/tum/in/www1/artemis/domain/ProgrammingExercise.java b/src/main/java/de/tum/in/www1/artemis/domain/ProgrammingExercise.java
index 77c81184c29a..2cbed9905590 100644
--- a/src/main/java/de/tum/in/www1/artemis/domain/ProgrammingExercise.java
+++ b/src/main/java/de/tum/in/www1/artemis/domain/ProgrammingExercise.java
@@ -47,6 +47,7 @@
 import de.tum.in.www1.artemis.domain.enumeration.ProjectType;
 import de.tum.in.www1.artemis.domain.enumeration.RepositoryType;
 import de.tum.in.www1.artemis.domain.enumeration.SubmissionType;
+import de.tum.in.www1.artemis.domain.enumeration.Visibility;
 import de.tum.in.www1.artemis.domain.hestia.ExerciseHint;
 import de.tum.in.www1.artemis.domain.hestia.ProgrammingExerciseTask;
 import de.tum.in.www1.artemis.domain.participation.Participation;
@@ -942,4 +943,15 @@ public String getBuildScript() {
     public void setBuildScript(String buildScript) {
         this.buildScript = buildScript;
     }
+
+    /**
+     * In course exercises students shall receive immediate feedback. {@link Visibility#ALWAYS}
+     * In Exams misconfiguration and leaking test results to students during an exam shall be prevented by the default setting. {@link Visibility#AFTER_DUE_DATE}
+     *
+     * @return default visibility {@link Visibility} set after the first execution of a test case
+     *         or when resetting the test case settings
+     */
+    public Visibility getDefaultTestCaseVisibility() {
+        return this.isExamExercise() ? Visibility.AFTER_DUE_DATE : Visibility.ALWAYS;
+    }
 }
diff --git a/src/main/java/de/tum/in/www1/artemis/service/exam/ExamImportService.java b/src/main/java/de/tum/in/www1/artemis/service/exam/ExamImportService.java
index 0b8caa4f6350..ba38ee1df128 100644
--- a/src/main/java/de/tum/in/www1/artemis/service/exam/ExamImportService.java
+++ b/src/main/java/de/tum/in/www1/artemis/service/exam/ExamImportService.java
@@ -319,7 +319,8 @@ private void addExercisesToExerciseGroup(ExerciseGroup exerciseGroupToCopy, Exer
                     originalProgrammingExercise.setTasks(new ArrayList<>(templateTasks));
 
                     prepareProgrammingExerciseForExamImport((ProgrammingExercise) exerciseToCopy);
-                    yield Optional.of(programmingExerciseImportService.importProgrammingExercise(originalProgrammingExercise, (ProgrammingExercise) exerciseToCopy, false, false));
+                    yield Optional
+                            .of(programmingExerciseImportService.importProgrammingExercise(originalProgrammingExercise, (ProgrammingExercise) exerciseToCopy, false, false, false));
                 }
 
                 case FILE_UPLOAD -> {
diff --git a/src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseFeedbackCreationService.java b/src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseFeedbackCreationService.java
index 4a87bd518bc3..0fefe43914de 100644
--- a/src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseFeedbackCreationService.java
+++ b/src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseFeedbackCreationService.java
@@ -160,7 +160,7 @@ private String removeCIDirectoriesFromPath(String sourcePath) {
      * Transforms static code analysis reports to feedback objects.
      * As we reuse the Feedback entity to store static code analysis findings, a mapping to those attributes
      * has to be defined, violating the first normal form.
-     * <p>
+     * <br>
      * Mapping:
      * - text: STATIC_CODE_ANALYSIS_FEEDBACK_IDENTIFIER
      * - reference: Tool
@@ -353,10 +353,12 @@ public void setTestCaseType(Set<ProgrammingExerciseTestCase> testCases, Programm
     }
 
     private Set<ProgrammingExerciseTestCase> getTestCasesFromBuildResult(AbstractBuildResultNotificationDTO buildResult, ProgrammingExercise exercise) {
+        Visibility defaultVisibility = exercise.getDefaultTestCaseVisibility();
+
         return buildResult.getBuildJobs().stream().flatMap(job -> Stream.concat(job.getFailedTests().stream(), job.getSuccessfulTests().stream()))
                 // we use default values for weight, bonus multiplier and bonus points
                 .map(testCase -> new ProgrammingExerciseTestCase().testName(testCase.getName()).weight(1.0).bonusMultiplier(1.0).bonusPoints(0.0).exercise(exercise).active(true)
-                        .visibility(Visibility.ALWAYS))
+                        .visibility(defaultVisibility))
                 .collect(Collectors.toSet());
     }
 
diff --git a/src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseImportService.java b/src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseImportService.java
index 6acd53b3f22f..135661c2cf82 100644
--- a/src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseImportService.java
+++ b/src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseImportService.java
@@ -6,9 +6,11 @@
 
 import java.io.IOException;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 
 import org.eclipse.jgit.api.errors.GitAPIException;
 import org.slf4j.Logger;
@@ -20,12 +22,15 @@
 
 import de.tum.in.www1.artemis.domain.AuxiliaryRepository;
 import de.tum.in.www1.artemis.domain.ProgrammingExercise;
+import de.tum.in.www1.artemis.domain.ProgrammingExerciseTestCase;
 import de.tum.in.www1.artemis.domain.Repository;
 import de.tum.in.www1.artemis.domain.User;
 import de.tum.in.www1.artemis.domain.VcsRepositoryUri;
 import de.tum.in.www1.artemis.domain.enumeration.BuildPlanType;
 import de.tum.in.www1.artemis.domain.enumeration.RepositoryType;
+import de.tum.in.www1.artemis.domain.enumeration.Visibility;
 import de.tum.in.www1.artemis.repository.AuxiliaryRepositoryRepository;
+import de.tum.in.www1.artemis.repository.ProgrammingExerciseTestCaseRepository;
 import de.tum.in.www1.artemis.repository.UserRepository;
 import de.tum.in.www1.artemis.service.FileService;
 import de.tum.in.www1.artemis.service.UriService;
@@ -65,11 +70,13 @@ public class ProgrammingExerciseImportService {
 
     private final ProgrammingExerciseImportBasicService programmingExerciseImportBasicService;
 
+    private final ProgrammingExerciseTestCaseRepository programmingExerciseTestCaseRepository;
+
     public ProgrammingExerciseImportService(Optional<VersionControlService> versionControlService, Optional<ContinuousIntegrationService> continuousIntegrationService,
             Optional<ContinuousIntegrationTriggerService> continuousIntegrationTriggerService, ProgrammingExerciseService programmingExerciseService,
             ProgrammingExerciseTaskService programmingExerciseTaskService, GitService gitService, FileService fileService, UserRepository userRepository,
             AuxiliaryRepositoryRepository auxiliaryRepositoryRepository, UriService uriService, TemplateUpgradePolicyService templateUpgradePolicyService,
-            ProgrammingExerciseImportBasicService programmingExerciseImportBasicService) {
+            ProgrammingExerciseImportBasicService programmingExerciseImportBasicService, ProgrammingExerciseTestCaseRepository programmingExerciseTestCaseRepository) {
         this.versionControlService = versionControlService;
         this.continuousIntegrationService = continuousIntegrationService;
         this.continuousIntegrationTriggerService = continuousIntegrationTriggerService;
@@ -82,6 +89,7 @@ public ProgrammingExerciseImportService(Optional<VersionControlService> versionC
         this.uriService = uriService;
         this.templateUpgradePolicyService = templateUpgradePolicyService;
         this.programmingExerciseImportBasicService = programmingExerciseImportBasicService;
+        this.programmingExerciseTestCaseRepository = programmingExerciseTestCaseRepository;
     }
 
     /**
@@ -271,14 +279,15 @@ private void adjustProjectName(Map<String, String> replacements, String projectK
      * Method to import a programming exercise, including all base build plans (template, solution) and repositories (template, solution, test).
      * Referenced entities, s.a. the test cases or the hints will get cloned and assigned a new id.
      *
-     * @param originalProgrammingExercise the Programming Exercise which should be used as a blueprint
-     * @param newProgrammingExercise      The new exercise already containing values which should not get copied, i.e. overwritten
-     * @param updateTemplate              if the template files should be updated
-     * @param recreateBuildPlans          if the build plans should be recreated
+     * @param originalProgrammingExercise         the Programming Exercise which should be used as a blueprint
+     * @param newProgrammingExercise              The new exercise already containing values which should not get copied, i.e. overwritten
+     * @param updateTemplate                      if the template files should be updated
+     * @param recreateBuildPlans                  if the build plans should be recreated
+     * @param setTestCaseVisibilityToAfterDueDate if the test case visibility should be set to {@link Visibility#AFTER_DUE_DATE}
      * @return the imported programming exercise
      */
     public ProgrammingExercise importProgrammingExercise(ProgrammingExercise originalProgrammingExercise, ProgrammingExercise newProgrammingExercise, boolean updateTemplate,
-            boolean recreateBuildPlans) throws JsonProcessingException {
+            boolean recreateBuildPlans, boolean setTestCaseVisibilityToAfterDueDate) throws JsonProcessingException {
         // remove all non-alphanumeric characters from the short name. This gets already done in the client, but we do it again here to be sure
         newProgrammingExercise.setShortName(newProgrammingExercise.getShortName().replaceAll("[^a-zA-Z0-9]", ""));
         newProgrammingExercise.generateAndSetProjectKey();
@@ -292,6 +301,15 @@ public ProgrammingExercise importProgrammingExercise(ProgrammingExercise origina
         newProgrammingExercise = programmingExerciseImportBasicService.importProgrammingExerciseBasis(originalProgrammingExercise, newProgrammingExercise);
         importRepositories(originalProgrammingExercise, newProgrammingExercise);
 
+        if (setTestCaseVisibilityToAfterDueDate) {
+            Set<ProgrammingExerciseTestCase> testCases = this.programmingExerciseTestCaseRepository.findByExerciseId(newProgrammingExercise.getId());
+            for (ProgrammingExerciseTestCase testCase : testCases) {
+                testCase.setVisibility(Visibility.AFTER_DUE_DATE);
+            }
+            List<ProgrammingExerciseTestCase> updatedTestCases = programmingExerciseTestCaseRepository.saveAll(testCases);
+            newProgrammingExercise.setTestCases(new HashSet<>(updatedTestCases));
+        }
+
         // Update the template files
         if (updateTemplate) {
             TemplateUpgradeService upgradeService = templateUpgradePolicyService.getUpgradeService(newProgrammingExercise.getProgrammingLanguage());
diff --git a/src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseTestCaseService.java b/src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseTestCaseService.java
index a70996c86f12..c6b40bd2ac55 100644
--- a/src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseTestCaseService.java
+++ b/src/main/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseTestCaseService.java
@@ -21,7 +21,6 @@
 import de.tum.in.www1.artemis.domain.ProgrammingExercise;
 import de.tum.in.www1.artemis.domain.ProgrammingExerciseTestCase;
 import de.tum.in.www1.artemis.domain.User;
-import de.tum.in.www1.artemis.domain.enumeration.Visibility;
 import de.tum.in.www1.artemis.repository.ProgrammingExerciseRepository;
 import de.tum.in.www1.artemis.repository.ProgrammingExerciseTestCaseRepository;
 import de.tum.in.www1.artemis.service.hestia.ProgrammingExerciseTaskService;
@@ -125,21 +124,21 @@ private static void validateTestCase(ProgrammingExerciseTestCase testCase) {
     /**
      * Reset all tests to their initial configuration
      *
-     * @param exerciseId to find exercise test cases
+     * @param programmingExercise that shall be reset
      * @return test cases that have been reset
      */
-    public List<ProgrammingExerciseTestCase> reset(Long exerciseId) {
-        Set<ProgrammingExerciseTestCase> testCases = this.testCaseRepository.findByExerciseId(exerciseId);
+    public List<ProgrammingExerciseTestCase> reset(ProgrammingExercise programmingExercise) {
+        Set<ProgrammingExerciseTestCase> testCases = this.testCaseRepository.findByExerciseId(programmingExercise.getId());
         for (ProgrammingExerciseTestCase testCase : testCases) {
             testCase.setWeight(1.0);
             testCase.setBonusMultiplier(1.0);
             testCase.setBonusPoints(0.0);
-            testCase.setVisibility(Visibility.ALWAYS);
+            testCase.setVisibility(programmingExercise.getDefaultTestCaseVisibility());
         }
         List<ProgrammingExerciseTestCase> updatedTestCases = testCaseRepository.saveAll(testCases);
 
         // The tests' weights were updated. We use this flag to inform the instructor about outdated student results.
-        programmingTriggerService.setTestCasesChangedAndTriggerTestCaseUpdate(exerciseId);
+        programmingTriggerService.setTestCasesChangedAndTriggerTestCaseUpdate(programmingExercise.getId());
         return updatedTestCases;
     }
 
diff --git a/src/main/java/de/tum/in/www1/artemis/web/rest/programming/ProgrammingExerciseExportImportResource.java b/src/main/java/de/tum/in/www1/artemis/web/rest/programming/ProgrammingExerciseExportImportResource.java
index 6e0e1bd3a1b1..21c0de2c44b9 100644
--- a/src/main/java/de/tum/in/www1/artemis/web/rest/programming/ProgrammingExerciseExportImportResource.java
+++ b/src/main/java/de/tum/in/www1/artemis/web/rest/programming/ProgrammingExerciseExportImportResource.java
@@ -45,6 +45,7 @@
 import de.tum.in.www1.artemis.domain.ProgrammingExercise;
 import de.tum.in.www1.artemis.domain.User;
 import de.tum.in.www1.artemis.domain.enumeration.RepositoryType;
+import de.tum.in.www1.artemis.domain.enumeration.Visibility;
 import de.tum.in.www1.artemis.domain.participation.ProgrammingExerciseStudentParticipation;
 import de.tum.in.www1.artemis.domain.participation.StudentParticipation;
 import de.tum.in.www1.artemis.repository.AuxiliaryRepositoryRepository;
@@ -166,21 +167,23 @@ private void validateStaticCodeAnalysisSettings(ProgrammingExercise programmingE
      * This will import the whole exercise, including all base build plans (template, solution) and repositories
      * (template, solution, test). Referenced entities, s.a. the test cases or the hints will get cloned and assigned
      * a new id. For a concrete list of what gets copied and what not have a look
-     * at {@link ProgrammingExerciseImportService#importProgrammingExercise(ProgrammingExercise, ProgrammingExercise, boolean, boolean)}
+     * at {@link ProgrammingExerciseImportService#importProgrammingExercise(ProgrammingExercise, ProgrammingExercise, boolean, boolean, boolean)}
      *
-     * @param sourceExerciseId   The ID of the original exercise which should get imported
-     * @param newExercise        The new exercise containing values that should get overwritten in the imported exercise, s.a. the title or difficulty
-     * @param recreateBuildPlans Option determining whether the build plans should be copied or re-created from scratch
-     * @param updateTemplate     Option determining whether the template files should be updated with the most recent template version
+     * @param sourceExerciseId                    The ID of the original exercise which should get imported
+     * @param newExercise                         The new exercise containing values that should get overwritten in the imported exercise, s.a. the title or difficulty
+     * @param recreateBuildPlans                  Option determining whether the build plans should be copied or re-created from scratch
+     * @param updateTemplate                      Option determining whether the template files should be updated with the most recent template version
+     * @param setTestCaseVisibilityToAfterDueDate Option determining whether the test case visibility should be set to {@link Visibility#AFTER_DUE_DATE}
      * @return The imported exercise (200), a not found error (404) if the template does not exist, or a forbidden error
      *         (403) if the user is not at least an instructor in the target course.
-     * @see ProgrammingExerciseImportService#importProgrammingExercise(ProgrammingExercise, ProgrammingExercise, boolean, boolean)
+     * @see ProgrammingExerciseImportService#importProgrammingExercise(ProgrammingExercise, ProgrammingExercise, boolean, boolean, boolean)
      */
     @PostMapping("programming-exercises/import/{sourceExerciseId}")
     @EnforceAtLeastEditor
     @FeatureToggle(Feature.ProgrammingExercises)
     public ResponseEntity<ProgrammingExercise> importProgrammingExercise(@PathVariable long sourceExerciseId, @RequestBody ProgrammingExercise newExercise,
-            @RequestParam(defaultValue = "false") boolean recreateBuildPlans, @RequestParam(defaultValue = "false") boolean updateTemplate) throws JsonProcessingException {
+            @RequestParam(defaultValue = "false") boolean recreateBuildPlans, @RequestParam(defaultValue = "false") boolean updateTemplate,
+            @RequestParam(defaultValue = "false") boolean setTestCaseVisibilityToAfterDueDate) throws JsonProcessingException {
         if (sourceExerciseId < 0) {
             throw new BadRequestAlertException("Invalid source id when importing programming exercises", ENTITY_NAME, "invalidSourceExerciseId");
         }
@@ -194,7 +197,7 @@ public ResponseEntity<ProgrammingExercise> importProgrammingExercise(@PathVariab
         newExercise.validateSettingsForFeedbackRequest();
         validateStaticCodeAnalysisSettings(newExercise);
 
-        final var user = userRepository.getUserWithGroupsAndAuthorities();
+        final User user = userRepository.getUserWithGroupsAndAuthorities();
         Course course = courseService.retrieveCourseOverExerciseGroupOrCourseId(newExercise);
         authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.EDITOR, course, user);
 
@@ -241,7 +244,7 @@ public ResponseEntity<ProgrammingExercise> importProgrammingExercise(@PathVariab
 
         try {
             ProgrammingExercise importedProgrammingExercise = programmingExerciseImportService.importProgrammingExercise(originalProgrammingExercise, newExercise, updateTemplate,
-                    recreateBuildPlans);
+                    recreateBuildPlans, setTestCaseVisibilityToAfterDueDate);
 
             // remove certain properties which are not relevant for the client to keep the response small
             importedProgrammingExercise.setTestCases(null);
diff --git a/src/main/java/de/tum/in/www1/artemis/web/rest/programming/ProgrammingExerciseTestCaseResource.java b/src/main/java/de/tum/in/www1/artemis/web/rest/programming/ProgrammingExerciseTestCaseResource.java
index 48a3f18d77d7..b3194bb0e142 100644
--- a/src/main/java/de/tum/in/www1/artemis/web/rest/programming/ProgrammingExerciseTestCaseResource.java
+++ b/src/main/java/de/tum/in/www1/artemis/web/rest/programming/ProgrammingExerciseTestCaseResource.java
@@ -16,7 +16,9 @@
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import de.tum.in.www1.artemis.domain.ProgrammingExercise;
 import de.tum.in.www1.artemis.domain.ProgrammingExerciseTestCase;
+import de.tum.in.www1.artemis.domain.User;
 import de.tum.in.www1.artemis.repository.ProgrammingExerciseRepository;
 import de.tum.in.www1.artemis.repository.ProgrammingExerciseTestCaseRepository;
 import de.tum.in.www1.artemis.repository.UserRepository;
@@ -120,13 +122,13 @@ public ResponseEntity<Set<ProgrammingExerciseTestCase>> updateTestCases(@PathVar
     @EnforceAtLeastEditor
     public ResponseEntity<List<ProgrammingExerciseTestCase>> resetTestCases(@PathVariable Long exerciseId) {
         log.debug("REST request to reset the test case weights of exercise {}", exerciseId);
-        var programmingExercise = programmingExerciseRepository.findByIdElseThrow(exerciseId);
-        var user = userRepository.getUserWithGroupsAndAuthorities();
+        ProgrammingExercise programmingExercise = programmingExerciseRepository.findByIdElseThrow(exerciseId);
+        User user = userRepository.getUserWithGroupsAndAuthorities();
 
         authCheckService.checkHasAtLeastRoleForExerciseElseThrow(Role.EDITOR, programmingExercise, user);
         programmingExerciseTestCaseService.logTestCaseReset(user, programmingExercise, programmingExercise.getCourseViaExerciseGroupOrCourseMember());
 
-        List<ProgrammingExerciseTestCase> testCases = programmingExerciseTestCaseService.reset(exerciseId);
+        List<ProgrammingExerciseTestCase> testCases = programmingExerciseTestCaseService.reset(programmingExercise);
         return ResponseEntity.ok(testCases);
     }
 }
diff --git a/src/main/webapp/app/exam/manage/student-exams/student-exam-detail.component.html b/src/main/webapp/app/exam/manage/student-exams/student-exam-detail.component.html
index a3cca888f9bb..c7dcd480e6e8 100644
--- a/src/main/webapp/app/exam/manage/student-exams/student-exam-detail.component.html
+++ b/src/main/webapp/app/exam/manage/student-exams/student-exam-detail.component.html
@@ -120,9 +120,7 @@ <h5><span jhiTranslate="artemisApp.studentExams.participationStatus"></span></h5
                             @if (!studentExam.submitted) {
                                 <span jhiTranslate="entity.action.toggleToSubmitted"></span>
                             } @else {
-                                @if (studentExam.submitted) {
-                                    <span jhiTranslate="entity.action.toggleToUnsubmitted"></span>
-                                }
+                                <span jhiTranslate="entity.action.toggleToUnsubmitted"></span>
                             }
                         </button>
                     }
diff --git a/src/main/webapp/app/exam/manage/student-exams/student-exam-detail.component.ts b/src/main/webapp/app/exam/manage/student-exams/student-exam-detail.component.ts
index 32cba7073ac4..817b93ffddb9 100644
--- a/src/main/webapp/app/exam/manage/student-exams/student-exam-detail.component.ts
+++ b/src/main/webapp/app/exam/manage/student-exams/student-exam-detail.component.ts
@@ -64,7 +64,7 @@ export class StudentExamDetailComponent implements OnInit, OnDestroy {
                 this.examId = params.examId;
                 this.courseId = params.courseId;
                 this.setStudentExamWithGrade(data.studentExam);
-                this.isTestExam = data.studentExam.exam.testExam;
+                this.isTestExam = data.studentExam.exam?.testExam;
                 this.isTestRun = url[1]?.toString() === 'test-runs';
             });
     }
diff --git a/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-grading-tasks-table.component.html b/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-grading-tasks-table.component.html
index 9a4201087b0b..52934fae6007 100644
--- a/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-grading-tasks-table.component.html
+++ b/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-grading-tasks-table.component.html
@@ -93,7 +93,10 @@ <h2 class="fw-medium">Tasks</h2>
         <button
             type="button"
             class="task__row__cell sort__button"
-            [ngbTooltip]="'artemisApp.programmingExercise.configureGrading.help.visibility' | artemisTranslate"
+            [ngbTooltip]="
+                (this.isExamExercise ? 'artemisApp.programmingExercise.configureGrading.help.visibilityExam' : 'artemisApp.programmingExercise.configureGrading.help.visibility')
+                    | artemisTranslate
+            "
             placement="bottom auto"
             (click)="changeSort('visibility')"
         >
@@ -128,6 +131,6 @@ <h2 class="fw-medium">Tasks</h2>
         </div>
     </div>
     @for (task of tasks; track task; let i = $index) {
-        <jhi-programming-exercise-task [index]="i" [task]="task" [openSubject]="allTasksExpandedSubject" (updateTasksEvent)="updateTasks()" />
+        <jhi-programming-exercise-task [index]="i" [task]="task" [openSubject]="allTasksExpandedSubject" (updateTasksEvent)="updateTasks()" [isExamExercise]="isExamExercise" />
     }
 </form>
diff --git a/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-grading-tasks-table.component.ts b/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-grading-tasks-table.component.ts
index 4874916d3210..8b4941a0e9fa 100644
--- a/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-grading-tasks-table.component.ts
+++ b/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-grading-tasks-table.component.ts
@@ -7,6 +7,7 @@ import { ProgrammingExerciseGradingStatistics } from 'app/entities/programming-e
 import { ProgrammingExerciseTask } from './programming-exercise-task';
 import { Observable, Subject } from 'rxjs';
 import { ProgrammingExerciseTestCase } from 'app/entities/programming-exercise-test-case.model';
+import { isExamExercise } from 'app/shared/util/utils';
 
 type Sort = {
     by: 'name' | 'weight' | 'multiplier' | 'bonusPoints' | 'visibility' | 'resulting' | 'type';
@@ -39,6 +40,8 @@ export class ProgrammingExerciseGradingTasksTableComponent implements OnInit {
 
     currentSort: Sort | undefined;
 
+    isExamExercise: boolean = false;
+
     get ignoreInactive() {
         return this.taskService.ignoreInactive;
     }
@@ -55,6 +58,8 @@ export class ProgrammingExerciseGradingTasksTableComponent implements OnInit {
             by: 'name',
             descending: true,
         };
+
+        this.isExamExercise = isExamExercise(this.exercise);
     }
 
     updateTasks = () => {
diff --git a/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-task/programming-exercise-task.component.html b/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-task/programming-exercise-task.component.html
index a76b4bd5522d..73b6b960effa 100644
--- a/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-task/programming-exercise-task.component.html
+++ b/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-task/programming-exercise-task.component.html
@@ -52,9 +52,9 @@
                         name="{{ task.taskName }}-visibility"
                         (change)="taskUpdateHandler()"
                     >
-                        @for (s of testCaseVisibilityList; track s) {
-                            <option [value]="s.value">
-                                {{ 'artemisApp.programmingExerciseTestCase.visibility.' + s.name | artemisTranslate }}
+                        @for (testCaseVisibility of testCaseVisibilityList; track testCaseVisibility) {
+                            <option [value]="testCaseVisibility.value">
+                                {{ 'artemisApp.programmingExerciseTestCase.visibility.' + testCaseVisibility.name | artemisTranslate }}
                             </option>
                         }
                     </select>
@@ -104,9 +104,9 @@
                     </div>
                     <div class="task__row__cell">
                         <select [(ngModel)]="test.visibility" class="form-select" name="{{ test.testName }}-visibility" (change)="testUpdateHandler(test)">
-                            @for (s of testCaseVisibilityList; track s) {
-                                <option [value]="s.value">
-                                    {{ 'artemisApp.programmingExerciseTestCase.visibility.' + s.name | artemisTranslate }}
+                            @for (testCaseVisibility of testCaseVisibilityList; track testCaseVisibility) {
+                                <option [value]="testCaseVisibility.value">
+                                    {{ 'artemisApp.programmingExerciseTestCase.visibility.' + testCaseVisibility.name | artemisTranslate }}
                                 </option>
                             }
                         </select>
diff --git a/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-task/programming-exercise-task.component.ts b/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-task/programming-exercise-task.component.ts
index 59d01f278793..d8c77b50c8df 100644
--- a/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-task/programming-exercise-task.component.ts
+++ b/src/main/webapp/app/exercises/programming/manage/grading/tasks/programming-exercise-task/programming-exercise-task.component.ts
@@ -14,6 +14,7 @@ export class ProgrammingExerciseTaskComponent implements OnInit {
     @Input() index: number;
     @Input() task: ProgrammingExerciseTask;
     @Input() openSubject: Subject<boolean>;
+    @Input() isExamExercise: boolean;
 
     @Output() updateTasksEvent = new EventEmitter<void>();
 
@@ -24,7 +25,7 @@ export class ProgrammingExerciseTaskComponent implements OnInit {
     readonly NOT_ASSIGNED_TO_TASK_NAME = 'Not assigned to task';
     open: boolean;
     onlyViewTestCases: boolean;
-    testCaseVisibilityList = Object.entries(Visibility).map(([name, value]) => ({ value, name }));
+    testCaseVisibilityList: { value: Visibility; name: string }[] = [];
 
     get numParticipations(): number {
         return this.programmingExerciseTaskService?.gradingStatistics?.numParticipations ?? 0;
@@ -40,6 +41,8 @@ export class ProgrammingExerciseTaskComponent implements OnInit {
             this.onlyViewTestCases = true;
             this.open = true;
         }
+
+        this.updateTestCaseVisibilityList();
     }
 
     testUpdateHandler(test: ProgrammingExerciseTestCase) {
@@ -75,4 +78,19 @@ export class ProgrammingExerciseTaskComponent implements OnInit {
     formatTestIndex(i: number, j: number): string {
         return `${i + 1}.${j + 1}`;
     }
+
+    private updateTestCaseVisibilityList() {
+        this.testCaseVisibilityList = Object.entries(Visibility).map(([name, value]) => {
+            let displayName = name;
+
+            if (this.isExamExercise && value === Visibility.AfterDueDate) {
+                displayName = 'AfterReleaseDateOfResults';
+            }
+
+            return {
+                value,
+                name: displayName,
+            };
+        });
+    }
 }
diff --git a/src/main/webapp/app/exercises/programming/manage/services/programming-exercise.service.ts b/src/main/webapp/app/exercises/programming/manage/services/programming-exercise.service.ts
index 6704124bf806..c0c6469b93b1 100644
--- a/src/main/webapp/app/exercises/programming/manage/services/programming-exercise.service.ts
+++ b/src/main/webapp/app/exercises/programming/manage/services/programming-exercise.service.ts
@@ -25,6 +25,7 @@ import { SortService } from 'app/shared/service/sort.service';
 import { Result } from 'app/entities/result.model';
 import { Participation } from 'app/entities/participation/participation.model';
 import { PlagiarismResultDTO } from 'app/exercises/shared/plagiarism/types/PlagiarismResultDTO';
+import { ImportOptions } from 'app/types/programming-exercises';
 
 export type EntityResponseType = HttpResponse<ProgrammingExercise>;
 export type EntityArrayResponseType = HttpResponse<ProgrammingExercise[]>;
@@ -153,12 +154,12 @@ export class ProgrammingExerciseService {
      *                                         new exercise. E.g. with another title than the original exercise. Old
      *                                         values that should get discarded (like the old ID) will be handled by the
      *                                         server.
-     * @param recreateBuildPlans Option determining whether the build plans should be recreated or copied from the imported exercise
-     * @param updateTemplate Option determining whether the template files in the repositories should be updated
+     * @param importOptions see {@link ImportOptions}
      */
-    importExercise(adaptedSourceProgrammingExercise: ProgrammingExercise, recreateBuildPlans: boolean, updateTemplate: boolean): Observable<EntityResponseType> {
-        const options = createRequestOption({ recreateBuildPlans, updateTemplate });
+    importExercise(adaptedSourceProgrammingExercise: ProgrammingExercise, importOptions: ImportOptions): Observable<EntityResponseType> {
+        const options = createRequestOption(importOptions);
         const exercise = ExerciseService.setBonusPointsConstrainedByIncludedInOverallScore(adaptedSourceProgrammingExercise);
+
         exercise.categories = ExerciseService.stringifyExerciseCategories(exercise);
         return this.http
             .post<ProgrammingExercise>(`${this.resourceUrl}/import/${adaptedSourceProgrammingExercise.id}`, exercise, {
diff --git a/src/main/webapp/app/exercises/programming/manage/update/programming-exercise-update.component.html b/src/main/webapp/app/exercises/programming/manage/update/programming-exercise-update.component.html
index f491048d3360..264d317dcab7 100644
--- a/src/main/webapp/app/exercises/programming/manage/update/programming-exercise-update.component.html
+++ b/src/main/webapp/app/exercises/programming/manage/update/programming-exercise-update.component.html
@@ -39,6 +39,7 @@ <h2 id="jhi-programming-exercise-heading-import" jhiTranslate="artemisApp.progra
                 class="form-step"
                 [programmingExercise]="programmingExercise"
                 [programmingExerciseCreationConfig]="getProgrammingExerciseCreationConfig()"
+                [importOptions]="importOptions"
             />
             @if (!isExamMode) {
                 <jhi-exercise-update-plagiarism [exercise]="programmingExercise" />
diff --git a/src/main/webapp/app/exercises/programming/manage/update/programming-exercise-update.component.ts b/src/main/webapp/app/exercises/programming/manage/update/programming-exercise-update.component.ts
index eb56735c16dc..2af04b36d26e 100644
--- a/src/main/webapp/app/exercises/programming/manage/update/programming-exercise-update.component.ts
+++ b/src/main/webapp/app/exercises/programming/manage/update/programming-exercise-update.component.ts
@@ -38,11 +38,7 @@ import { ProgrammingExerciseDifficultyComponent } from 'app/exercises/programmin
 import { ProgrammingExerciseLanguageComponent } from 'app/exercises/programming/manage/update/update-components/programming-exercise-language.component';
 import { ProgrammingExerciseGradingComponent } from 'app/exercises/programming/manage/update/update-components/programming-exercise-grading.component';
 import { ExerciseUpdatePlagiarismComponent } from 'app/exercises/shared/plagiarism/exercise-update-plagiarism/exercise-update-plagiarism.component';
-
-export interface ImportOptions {
-    recreateBuildPlans: boolean;
-    updateTemplate: boolean;
-}
+import { ImportOptions } from 'app/types/programming-exercises';
 
 @Component({
     selector: 'jhi-programming-exercise-update',
@@ -147,6 +143,7 @@ export class ProgrammingExerciseUpdateComponent implements AfterViewInit, OnDest
     public readonly importOptions: ImportOptions = {
         recreateBuildPlans: false,
         updateTemplate: false,
+        setTestCaseVisibilityToAfterDueDate: false,
     };
     public originalStaticCodeAnalysisEnabled: boolean | undefined;
 
@@ -643,9 +640,7 @@ export class ProgrammingExerciseUpdateComponent implements AfterViewInit, OnDest
         if (this.isImportFromFile) {
             this.subscribeToSaveResponse(this.programmingExerciseService.importFromFile(this.programmingExercise, this.courseId));
         } else if (this.isImportFromExistingExercise) {
-            this.subscribeToSaveResponse(
-                this.programmingExerciseService.importExercise(this.programmingExercise, this.importOptions.recreateBuildPlans, this.importOptions.updateTemplate),
-            );
+            this.subscribeToSaveResponse(this.programmingExerciseService.importExercise(this.programmingExercise, this.importOptions));
         } else if (this.programmingExercise.id !== undefined) {
             const requestOptions = {} as any;
             if (this.notificationText) {
diff --git a/src/main/webapp/app/exercises/programming/manage/update/update-components/programming-exercise-grading.component.html b/src/main/webapp/app/exercises/programming/manage/update/update-components/programming-exercise-grading.component.html
index 93235f21f3c4..cda675597e30 100644
--- a/src/main/webapp/app/exercises/programming/manage/update/update-components/programming-exercise-grading.component.html
+++ b/src/main/webapp/app/exercises/programming/manage/update/update-components/programming-exercise-grading.component.html
@@ -106,7 +106,13 @@ <h3 jhiTranslate="artemisApp.programmingExercise.wizardMode.detailedSteps.gradin
             <label jhiTranslate="artemisApp.programmingExercise.timeline.timelineLabel" for="timeline"></label>
             <jhi-help-icon placement="auto" text="artemisApp.programmingExercise.timeline.timelineTooltip" />
         </div>
-        <jhi-programming-exercise-lifecycle id="timeline" [exercise]="programmingExercise" [isExamMode]="programmingExerciseCreationConfig.isExamMode" [readOnly]="false" />
+        <jhi-programming-exercise-lifecycle
+            id="timeline"
+            [exercise]="programmingExercise"
+            [isExamMode]="programmingExerciseCreationConfig.isExamMode"
+            [readOnly]="false"
+            [importOptions]="importOptions"
+        />
     </div>
     @if (programmingExercise.assessmentType === AssessmentType.SEMI_AUTOMATIC) {
         <div class="form-group">
diff --git a/src/main/webapp/app/exercises/programming/manage/update/update-components/programming-exercise-grading.component.ts b/src/main/webapp/app/exercises/programming/manage/update/update-components/programming-exercise-grading.component.ts
index fa49e4b91adf..b82813fa9f06 100644
--- a/src/main/webapp/app/exercises/programming/manage/update/update-components/programming-exercise-grading.component.ts
+++ b/src/main/webapp/app/exercises/programming/manage/update/update-components/programming-exercise-grading.component.ts
@@ -10,6 +10,7 @@ import { Subject, Subscription } from 'rxjs';
 import { NgModel } from '@angular/forms';
 import { SubmissionPolicyUpdateComponent } from 'app/exercises/shared/submission-policy/submission-policy-update.component';
 import { ProgrammingExerciseLifecycleComponent } from 'app/exercises/programming/shared/lifecycle/programming-exercise-lifecycle.component';
+import { ImportOptions } from 'app/types/programming-exercises';
 
 @Component({
     selector: 'jhi-programming-exercise-grading',
@@ -25,6 +26,7 @@ export class ProgrammingExerciseGradingComponent implements AfterViewInit, OnDes
 
     @Input() programmingExercise: ProgrammingExercise;
     @Input() programmingExerciseCreationConfig: ProgrammingExerciseCreationConfig;
+    @Input() importOptions: ImportOptions;
 
     @ViewChild(SubmissionPolicyUpdateComponent) submissionPolicyUpdateComponent?: SubmissionPolicyUpdateComponent;
     @ViewChild(ProgrammingExerciseLifecycleComponent) lifecycleComponent?: ProgrammingExerciseLifecycleComponent;
diff --git a/src/main/webapp/app/exercises/programming/manage/update/update-components/programming-exercise-information.component.ts b/src/main/webapp/app/exercises/programming/manage/update/update-components/programming-exercise-information.component.ts
index 77f5288ee8ef..b1bd35bca30a 100644
--- a/src/main/webapp/app/exercises/programming/manage/update/update-components/programming-exercise-information.component.ts
+++ b/src/main/webapp/app/exercises/programming/manage/update/update-components/programming-exercise-information.component.ts
@@ -2,11 +2,11 @@ import { AfterViewInit, Component, Input, OnDestroy, QueryList, ViewChild, ViewC
 import { NgModel } from '@angular/forms';
 import { ProgrammingExercise, ProjectType } from 'app/entities/programming-exercise.model';
 import { ProgrammingExerciseCreationConfig } from 'app/exercises/programming/manage/update/programming-exercise-creation-config';
-import { ImportOptions } from 'app/exercises/programming/manage/update/programming-exercise-update.component';
 import { ExerciseTitleChannelNameComponent } from 'app/exercises/shared/exercise-title-channel-name/exercise-title-channel-name.component';
 import { Subject, Subscription } from 'rxjs';
 import { TableEditableFieldComponent } from 'app/shared/table/table-editable-field.component';
 import { every } from 'lodash-es';
+import { ImportOptions } from 'app/types/programming-exercises';
 
 @Component({
     selector: 'jhi-programming-exercise-info',
diff --git a/src/main/webapp/app/exercises/programming/shared/lifecycle/programming-exercise-lifecycle.component.html b/src/main/webapp/app/exercises/programming/shared/lifecycle/programming-exercise-lifecycle.component.html
index 3c1650f7fd9d..9a32bc2a7b66 100644
--- a/src/main/webapp/app/exercises/programming/shared/lifecycle/programming-exercise-lifecycle.component.html
+++ b/src/main/webapp/app/exercises/programming/shared/lifecycle/programming-exercise-lifecycle.component.html
@@ -138,6 +138,24 @@ <h6 jhiTranslate="artemisApp.assessment.assessment"></h6>
                 <jhi-help-icon placement="right auto" [text]="'artemisApp.programmingExercise.timeline.complaintOnAutomaticAssessmentTooltip'" />
             </div>
         }
+        @if (isExamMode && isImport && importOptions) {
+            <div class="form-check">
+                <input
+                    type="checkbox"
+                    class="form-check-input"
+                    name="setTestCaseVisibilityToAfterDueDate"
+                    [checked]="importOptions.setTestCaseVisibilityToAfterDueDate"
+                    id="setTestCaseVisibilityToAfterDueDate-checkbox"
+                    (change)="toggleSetTestCaseVisibilityToAfterDueDate()"
+                />
+                <label
+                    class="form-control-label"
+                    for="setTestCaseVisibilityToAfterDueDate-checkbox"
+                    jhiTranslate="artemisApp.programmingExercise.timeline.setTestCaseVisibilityToAfterReleaseDateOfResults"
+                ></label>
+                <jhi-help-icon placement="right auto" [text]="'artemisApp.programmingExercise.timeline.setTestCaseVisibilityToAfterReleaseDateOfResultsTooltip'" />
+            </div>
+        }
         @if (!isExamMode) {
             <div class="form-check">
                 <input
diff --git a/src/main/webapp/app/exercises/programming/shared/lifecycle/programming-exercise-lifecycle.component.ts b/src/main/webapp/app/exercises/programming/shared/lifecycle/programming-exercise-lifecycle.component.ts
index 2a9bbe164002..9185f229d2ff 100644
--- a/src/main/webapp/app/exercises/programming/shared/lifecycle/programming-exercise-lifecycle.component.ts
+++ b/src/main/webapp/app/exercises/programming/shared/lifecycle/programming-exercise-lifecycle.component.ts
@@ -10,6 +10,9 @@ import { Observable, Subject, Subscription } from 'rxjs';
 import { AthenaService } from 'app/assessment/athena.service';
 import { ProgrammingExerciseTestScheduleDatePickerComponent } from 'app/exercises/programming/shared/lifecycle/programming-exercise-test-schedule-date-picker.component';
 import { every } from 'lodash-es';
+import { ActivatedRoute } from '@angular/router';
+import { tap } from 'rxjs/operators';
+import { ImportOptions } from 'app/types/programming-exercises';
 
 @Component({
     selector: 'jhi-programming-exercise-lifecycle',
@@ -20,6 +23,7 @@ export class ProgrammingExerciseLifecycleComponent implements AfterViewInit, OnD
     @Input() exercise: ProgrammingExercise;
     @Input() isExamMode: boolean;
     @Input() readOnly: boolean;
+    @Input() importOptions?: ImportOptions;
 
     @ViewChildren(ProgrammingExerciseTestScheduleDatePickerComponent) datePickerComponents: QueryList<ProgrammingExerciseTestScheduleDatePickerComponent>;
 
@@ -40,10 +44,14 @@ export class ProgrammingExerciseLifecycleComponent implements AfterViewInit, OnD
 
     isAthenaEnabled$: Observable<boolean> | undefined;
 
+    isImport: boolean = false;
+    private urlSubscription: Subscription;
+
     constructor(
         private translateService: TranslateService,
         private exerciseService: ExerciseService,
         private athenaService: AthenaService,
+        private activatedRoute: ActivatedRoute,
     ) {}
 
     /**
@@ -54,6 +62,23 @@ export class ProgrammingExerciseLifecycleComponent implements AfterViewInit, OnD
             this.exercise.assessmentType = AssessmentType.AUTOMATIC;
         }
         this.isAthenaEnabled$ = this.athenaService.isEnabled();
+
+        this.updateIsImportBasedOnUrl();
+    }
+
+    private updateIsImportBasedOnUrl() {
+        let isImportFromExistingExercise = false;
+        this.urlSubscription = this.activatedRoute.url
+            .pipe(
+                tap((segments) => {
+                    isImportFromExistingExercise = segments.some((segment) => segment.path === 'import');
+                    // currently not supported for imports from files, issue https://github.com/ls1intum/Artemis/issues/8562 should be fixed first
+                    // isImportFromFile = segments.some((segment) => segment.path === 'import-from-file');
+                }),
+            )
+            .subscribe(() => {
+                this.isImport = isImportFromExistingExercise;
+            });
     }
 
     ngAfterViewInit() {
@@ -78,6 +103,7 @@ export class ProgrammingExerciseLifecycleComponent implements AfterViewInit, OnD
     ngOnDestroy() {
         this.datePickerChildrenSubscription?.unsubscribe();
         this.unsubscribeDateFieldSubscriptions();
+        this.urlSubscription?.unsubscribe();
     }
 
     calculateFormStatus() {
@@ -100,6 +126,12 @@ export class ProgrammingExerciseLifecycleComponent implements AfterViewInit, OnD
         }
     }
 
+    toggleSetTestCaseVisibilityToAfterDueDate() {
+        if (this.importOptions) {
+            this.importOptions.setTestCaseVisibilityToAfterDueDate = !this.importOptions.setTestCaseVisibilityToAfterDueDate;
+        }
+    }
+
     toggleFeedbackRequests() {
         this.exercise.allowFeedbackRequests = !this.exercise.allowFeedbackRequests;
         if (this.exercise.allowFeedbackRequests) {
diff --git a/src/main/webapp/app/shared/util/utils.ts b/src/main/webapp/app/shared/util/utils.ts
index 9e9d40d0ca36..0a87dd8c8efd 100644
--- a/src/main/webapp/app/shared/util/utils.ts
+++ b/src/main/webapp/app/shared/util/utils.ts
@@ -2,6 +2,7 @@ import { omit, sum } from 'lodash-es';
 import { captureException } from '@sentry/angular-ivy';
 import { Result } from 'app/entities/result.model';
 import { Course } from 'app/entities/course.model';
+import { Exercise } from 'app/entities/exercise.model';
 
 // Cartesian product helper function
 const cartesianConcatHelper = (a: any[], b: any[]): any[][] => ([] as any[][]).concat(...a.map((a2) => b.map((b2) => ([] as any[]).concat(a2, b2))));
@@ -166,3 +167,12 @@ export function scrollToTopOfPage() {
         pageWrapper.scroll(0, 0);
     }
 }
+
+/**
+ * For exam exercises the course will not be set as exam exercises are linked via exercise groups.
+ *
+ * @param exercise for which is checked if it belongs to an exam
+ */
+export function isExamExercise(exercise: Exercise) {
+    return exercise.course === undefined;
+}
diff --git a/src/main/webapp/app/types/programming-exercises.ts b/src/main/webapp/app/types/programming-exercises.ts
new file mode 100644
index 000000000000..c0e64d581144
--- /dev/null
+++ b/src/main/webapp/app/types/programming-exercises.ts
@@ -0,0 +1,10 @@
+/**
+ * - {@link ImportOptions.recreateBuildPlans} Option determining whether the build plans should be recreated or copied from the imported exercise
+ * - {@link ImportOptions.updateTemplate} Option determining whether the template files in the repositories should be updated
+ * - {@link ImportOptions.setTestCaseVisibilityToAfterDueDate} Option determining whether the test cases should be hidden until the release date of the results
+ */
+export interface ImportOptions {
+    recreateBuildPlans: boolean;
+    updateTemplate: boolean;
+    setTestCaseVisibilityToAfterDueDate: boolean;
+}
diff --git a/src/main/webapp/i18n/de/programmingExercise.json b/src/main/webapp/i18n/de/programmingExercise.json
index b48f7bc7944d..84a6929ab568 100644
--- a/src/main/webapp/i18n/de/programmingExercise.json
+++ b/src/main/webapp/i18n/de/programmingExercise.json
@@ -316,6 +316,7 @@
                     "bonusMultiplier": "Bonusmultiplikator: Dies multipliziert die Punkte für das Bestehen eines Testfalls, ohne dabei die Anteile der anderen Testfälle zu beeinflussen. Multiplikatoren größer als 1 können zu Ergebnissen von mehr als 100% führen.",
                     "bonusPoints": "Bonuspunkte: Zusätzliche Punkte, die zu den regulären Punkten für das Bestehen eines Testfalls hinzuaddiert werden. Das Setzen von Bonuspunkten kann zu Ergebnissen von mehr als 100% führen.",
                     "visibility": "Feedback und Punkte für Testfälle, die mit „Nach Einreichungsfrist“ markiert sind, werden erst danach für Studierende angezeigt. Nie sichtbare Tests werden nicht in die Punktebewertung einbezogen.",
+                    "visibilityExam": "Feedback und Punkte für Testfälle, die mit „Nach Veröffentlichung der Ergebnisse“ markiert sind, werden erst nach der Veröffentlichung der Klausurergebnisse angezeigt. Nie sichtbare Tests werden nicht in die Punktebewertung einbezogen.",
                     "points": "Die Menge an Punkten, die die Studierenden für das Bestehen dieses Tests bekommen. Dieser Wert wird wie in den Kurseinstellungen festgelegt gerundet.",
                     "type": "Der Typ des Tests gibt an, ob dieser aus der test.json-Datei generiert wurde (STRUCTURAL), oder manuell geschrieben wurde (BEHAVIORAL)."
                 },
@@ -425,7 +426,9 @@
                 "complaintOnAutomaticAssessmentTooltip": "Die Studierenden dürfen eine Beschwerde nach einer automatischen Bewertung einlegen, die ein Tutor danach bewerten kann.",
                 "exampleSolutionPublicationDateTooltip": "Das Datum, an dem das Lösungsrepository für Studierende zum Herunterladen verfügbar wird. Zum Deaktivieren leer lassen.",
                 "releaseTestsWithExampleSolution": "Tests zusammen mit Lösungsvorschlag veröffentlichen",
-                "releaseTestsWithExampleSolutionTooltip": "Die automatischen Tests können zusätzlich zu dem Lösungsvorschlag nach der Einreichungsfrist zum Download bereit gestellt werden."
+                "releaseTestsWithExampleSolutionTooltip": "Die automatischen Tests können zusätzlich zu dem Lösungsvorschlag nach der Einreichungsfrist zum Download bereit gestellt werden.",
+                "setTestCaseVisibilityToAfterReleaseDateOfResults": "Testergebnisse erst nach Veröffentlichung der Ergebnisse sichtbar machen",
+                "setTestCaseVisibilityToAfterReleaseDateOfResultsTooltip": "Während der Klausur sehen Studierende nur, ob ihr Code kompiliert. Details zu den Testergebnissen werden erst nach dem Veröffentlichungsdatum der Ergebnisse angezeigt."
             },
             "repositoryIsLocked": {
                 "title": "Dein Repository ist gesperrt.",
diff --git a/src/main/webapp/i18n/de/programmingExerciseTestCase.json b/src/main/webapp/i18n/de/programmingExerciseTestCase.json
index 23adde109d47..650a9dab549a 100644
--- a/src/main/webapp/i18n/de/programmingExerciseTestCase.json
+++ b/src/main/webapp/i18n/de/programmingExerciseTestCase.json
@@ -21,6 +21,7 @@
             "visibility": {
                 "Always": "Immer",
                 "AfterDueDate": "Nach Einreichungsfrist",
+                "AfterReleaseDateOfResults": "Nach Veröffentlichung der Ergebnisse",
                 "Never": "Nie"
             },
             "type": {
diff --git a/src/main/webapp/i18n/en/programmingExercise.json b/src/main/webapp/i18n/en/programmingExercise.json
index 7cc5dfcca58a..9e87d39e5b3d 100644
--- a/src/main/webapp/i18n/en/programmingExercise.json
+++ b/src/main/webapp/i18n/en/programmingExercise.json
@@ -318,6 +318,7 @@
                     "bonusMultiplier": "Bonus multiplier: This multiplies the points given for passing a test case without affecting the fractions of other test cases. Multipliers greater than 1 can result in student scores greater than 100%.",
                     "bonusPoints": "Bonus points: Additional points added on top of the regular points for passing a test case. Setting bonus points can result in student scores greater than 100%.",
                     "visibility": "Feedback and points for test cases marked as ‘After Due Date’ only become visible to students after the due date has passed. Tests with visibility ‘Never’ do not influence the student score.",
+                    "visibilityExam": "Feedback and points for test cases marked as ‘After Release Date of Results’ only become visible to students after the exam results release date has passed. Tests with visibility ‘Never’ do not influence the student score.",
                     "points": "The amount of points the student gets for passing this test. This value is rounded according to the course settings.",
                     "type": "The type of the test case determines if the test case has been generated from the test.json (STRUCTURAL), or has been written manually (BEHAVIORAL)."
                 },
@@ -425,7 +426,9 @@
                 "complaintOnAutomaticAssessmentTooltip": "Students can complain after receiving an automatic assessment. Which will be evaluated by a tutor afterwards.",
                 "exampleSolutionPublicationDateTooltip": "The date when the Solution Repository becomes available to download for students. Leave blank to disable.",
                 "releaseTestsWithExampleSolution": "Include tests into example solution",
-                "releaseTestsWithExampleSolutionTooltip": "In addition to the example solution the automatic tests can be published after the due date."
+                "releaseTestsWithExampleSolutionTooltip": "In addition to the example solution the automatic tests can be published after the due date.",
+                "setTestCaseVisibilityToAfterReleaseDateOfResults": "Set test case visibility to After Release Date of Results",
+                "setTestCaseVisibilityToAfterReleaseDateOfResultsTooltip": "During the exam students will only see if their code compiles. Details about the test results will be displayed after the Release Date of Results."
             },
             "repositoryIsLocked": {
                 "title": "Your repository is locked.",
diff --git a/src/main/webapp/i18n/en/programmingExerciseTestCase.json b/src/main/webapp/i18n/en/programmingExerciseTestCase.json
index 5d590a2484a0..c7fc154ac130 100644
--- a/src/main/webapp/i18n/en/programmingExerciseTestCase.json
+++ b/src/main/webapp/i18n/en/programmingExerciseTestCase.json
@@ -21,6 +21,7 @@
             "visibility": {
                 "Always": "Always",
                 "AfterDueDate": "After Due Date",
+                "AfterReleaseDateOfResults": "After Release Date of Results",
                 "Never": "Never"
             },
             "type": {
diff --git a/src/test/cypress/e2e/exam/ExamAssessment.cy.ts b/src/test/cypress/e2e/exam/ExamAssessment.cy.ts
index 1af0388c1681..37c6a20822bc 100644
--- a/src/test/cypress/e2e/exam/ExamAssessment.cy.ts
+++ b/src/test/cypress/e2e/exam/ExamAssessment.cy.ts
@@ -57,7 +57,7 @@ describe('Exam assessment', () => {
             cy.login(instructor);
             examManagement.verifySubmitted(course.id!, exam.id!, studentOneName);
             cy.login(tutor);
-            startAssessing(course.id!, exam.id!, 155000);
+            startAssessing(course.id!, exam.id!, 175000);
             examAssessment.addNewFeedback(2, 'Good job');
             examAssessment.submit();
             cy.login(studentOne, '/courses/' + course.id + '/exams/' + exam.id);
diff --git a/src/test/cypress/e2e/exam/ExamDateVerification.cy.ts b/src/test/cypress/e2e/exam/ExamDateVerification.cy.ts
index 282a19c2e71e..f6cc2ee0bdea 100644
--- a/src/test/cypress/e2e/exam/ExamDateVerification.cy.ts
+++ b/src/test/cypress/e2e/exam/ExamDateVerification.cy.ts
@@ -69,7 +69,7 @@ describe.skip('Exam date verification', () => {
                 cy.url().should('contain', `${course.id}`);
                 courseOverview.openExamsTab();
                 courseOverview.openExam(exam.id!);
-                cy.url().should('contain', `/exams/${exam.id}`);
+                cy.url({ timeout: 40000 }).should('contain', `/exams/${exam.id}`);
             });
         });
 
diff --git a/src/test/cypress/support/pageobjects/course/CoursesPage.ts b/src/test/cypress/support/pageobjects/course/CoursesPage.ts
index 02161ab128aa..ffffee9b859c 100644
--- a/src/test/cypress/support/pageobjects/course/CoursesPage.ts
+++ b/src/test/cypress/support/pageobjects/course/CoursesPage.ts
@@ -3,7 +3,7 @@
  */
 export class CoursesPage {
     openCourse(courseId: number) {
-        cy.get(`#course-${courseId}-header`).click();
+        cy.get(`#course-${courseId}-header`, { timeout: 30000 }).click();
         cy.url().should('include', '/exercises');
     }
 }
diff --git a/src/test/cypress/support/pageobjects/exam/ExamExerciseGroupCreationPage.ts b/src/test/cypress/support/pageobjects/exam/ExamExerciseGroupCreationPage.ts
index 6c599c8cc36c..8f88dad63292 100644
--- a/src/test/cypress/support/pageobjects/exam/ExamExerciseGroupCreationPage.ts
+++ b/src/test/cypress/support/pageobjects/exam/ExamExerciseGroupCreationPage.ts
@@ -2,10 +2,11 @@ import { Exam } from 'app/entities/exam.model';
 
 import multipleChoiceTemplate from '../../../fixtures/exercise/quiz/multiple_choice/template.json';
 import { examAPIRequests, exerciseAPIRequest } from '../../artemis';
-import { AdditionalData, COURSE_BASE, Exercise, ExerciseType, PUT } from '../../constants';
-import { POST } from '../../constants';
+import { AdditionalData, COURSE_BASE, ExerciseType, POST, PUT } from '../../constants';
 import { convertModelAfterMultiPart, generateUUID } from '../../utils';
 import { QuizExercise } from 'app/entities/quiz/quiz-exercise.model';
+import { Exercise } from 'app/entities/exercise.model';
+import { Visibility } from 'app/entities/programming-exercise-test-case.model';
 
 /**
  * A class which encapsulates UI selectors and actions for the exam exercise group creation page.
@@ -40,6 +41,12 @@ export class ExamExerciseGroupCreationPage {
                     additionalData!.quizExerciseID = quiz.quizQuestions![0].id;
                     exercise = { ...quiz, additionalData };
                 }
+
+                if (exerciseType === ExerciseType.PROGRAMMING) {
+                    const RETRY_NUMBER = 0;
+                    exerciseAPIRequest.changeProgrammingExerciseTestVisibility(exercise, Visibility.Always, RETRY_NUMBER);
+                }
+
                 resolve(exercise);
             });
         });
diff --git a/src/test/cypress/support/requests/ExerciseAPIRequests.ts b/src/test/cypress/support/requests/ExerciseAPIRequests.ts
index 2bb4094736fb..124af6765a88 100644
--- a/src/test/cypress/support/requests/ExerciseAPIRequests.ts
+++ b/src/test/cypress/support/requests/ExerciseAPIRequests.ts
@@ -30,6 +30,7 @@ import {
     ExerciseType,
     GET,
     MODELING_EXERCISE_BASE,
+    PATCH,
     POST,
     PROGRAMMING_EXERCISE_BASE,
     PUT,
@@ -40,6 +41,18 @@ import {
     UPLOAD_EXERCISE_BASE,
 } from '../constants';
 import { dayjsToString, generateUUID, titleLowercase } from '../utils';
+import { ProgrammingExerciseTestCase, Visibility } from 'app/entities/programming-exercise-test-case.model';
+
+type PatchProgrammingExerciseTestVisibilityDto = {
+    id: number;
+    weight: number;
+    bonusPoints: number;
+    bonusMultiplier: number;
+    visibility: Visibility;
+}[];
+
+const MAX_RETRIES: number = 10;
+const RETRY_DELAY: number = 3000;
 
 /**
  * A class which encapsulates all API requests related to exercises.
@@ -134,6 +147,41 @@ export class ExerciseAPIRequests {
         });
     }
 
+    /**
+     * Retrieves the test cases for passed exercise and adjusts their visibility according.
+     * <br>
+     * Note: test cases are not available before the tests of the solution have completely run through
+     *       -> we need to do retries until the tests have been executed
+     *
+     * @param programmingExercise for which the test cases shall be set to {@link newVisibility}
+     * @param newVisibility that is applied for all found test cases
+     * @param retryNumber
+     */
+    changeProgrammingExerciseTestVisibility(programmingExercise: ProgrammingExercise, newVisibility: Visibility, retryNumber: number) {
+        if (retryNumber >= MAX_RETRIES) {
+            throw new Error('Could not find test cases (tests for solution might not be finished yet)');
+        }
+
+        cy.request({
+            url: `${PROGRAMMING_EXERCISE_BASE}/${programmingExercise.id}/test-cases`,
+            method: GET,
+        }).then((response) => {
+            const testCases = response.body as ProgrammingExerciseTestCase[];
+
+            if (retryNumber > 0) {
+                cy.log(`Could not find test cases yet, retrying... (${retryNumber} / ${MAX_RETRIES})`);
+            }
+
+            cy.wait(RETRY_DELAY);
+
+            if (testCases.length > 0) {
+                this.updateProgrammingExerciseTestCaseVisibility(programmingExercise.id!, testCases, newVisibility);
+            } else {
+                this.changeProgrammingExerciseTestVisibility(programmingExercise, newVisibility, retryNumber + 1);
+            }
+        });
+    }
+
     /**
      * Submits the example submission to the specified repository.
      *
@@ -525,6 +573,26 @@ export class ExerciseAPIRequests {
         });
     }
 
+    private updateProgrammingExerciseTestCaseVisibility(programmingExerciseId: number, programmingExerciseTestCases: ProgrammingExerciseTestCase[], newVisibility: Visibility) {
+        const updatedTestCaseSettings: PatchProgrammingExerciseTestVisibilityDto = [];
+
+        for (const testCase of programmingExerciseTestCases) {
+            updatedTestCaseSettings.push({
+                id: testCase.id!,
+                weight: testCase.weight!,
+                bonusPoints: testCase.bonusPoints!,
+                bonusMultiplier: testCase.bonusMultiplier!,
+                visibility: newVisibility,
+            });
+        }
+
+        return cy.request({
+            url: `${PROGRAMMING_EXERCISE_BASE}/${programmingExerciseId}/update-test-cases`,
+            method: PATCH,
+            body: updatedTestCaseSettings,
+        });
+    }
+
     private updateExercise(exercise: Exercise, type: ExerciseType) {
         let url: string;
         switch (type) {
diff --git a/src/test/java/de/tum/in/www1/artemis/exercise/programming/ProgrammingExerciseTestCaseServiceTest.java b/src/test/java/de/tum/in/www1/artemis/exercise/programming/ProgrammingExerciseTestCaseServiceTest.java
index bc0aad594c33..f1213082e8f1 100644
--- a/src/test/java/de/tum/in/www1/artemis/exercise/programming/ProgrammingExerciseTestCaseServiceTest.java
+++ b/src/test/java/de/tum/in/www1/artemis/exercise/programming/ProgrammingExerciseTestCaseServiceTest.java
@@ -26,6 +26,7 @@
 import de.tum.in.www1.artemis.domain.ProgrammingExerciseTestCase;
 import de.tum.in.www1.artemis.domain.enumeration.AssessmentType;
 import de.tum.in.www1.artemis.domain.enumeration.Visibility;
+import de.tum.in.www1.artemis.domain.exam.ExerciseGroup;
 import de.tum.in.www1.artemis.exercise.ExerciseUtilService;
 import de.tum.in.www1.artemis.participation.ParticipationUtilService;
 import de.tum.in.www1.artemis.repository.ProgrammingExerciseRepository;
@@ -77,8 +78,19 @@ void setUp() {
     }
 
     @Test
-    @WithMockUser(username = TEST_PREFIX + "tutor1", roles = "TA")
-    void shouldResetTestCases() throws Exception {
+    @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
+    void shouldResetCourseExerciseTestCases() throws Exception {
+        testResetTestCases(programmingExercise, Visibility.ALWAYS);
+    }
+
+    @Test
+    @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
+    void shouldResetExamExerciseTestCases() throws Exception {
+        programmingExercise.setExerciseGroup(new ExerciseGroup());
+        testResetTestCases(programmingExercise, Visibility.AFTER_DUE_DATE);
+    }
+
+    private void testResetTestCases(ProgrammingExercise programmingExercise, Visibility expectedVisibility) throws Exception {
         String dummyHash = "9b3a9bd71a0d80e5bbc42204c319ed3d1d4f0d6d";
         when(gitService.getLastCommitHash(any())).thenReturn(ObjectId.fromString(dummyHash));
         participationUtilService.addProgrammingParticipationWithResultForExercise(programmingExercise, TEST_PREFIX + "student1");
@@ -86,7 +98,7 @@ void shouldResetTestCases() throws Exception {
 
         assertThat(programmingExercise.getTestCasesChanged()).isFalse();
 
-        testCaseService.reset(programmingExercise.getId());
+        testCaseService.reset(programmingExercise);
 
         Set<ProgrammingExerciseTestCase> testCases = testCaseRepository.findByExerciseId(programmingExercise.getId());
         ProgrammingExercise updatedProgrammingExercise = programmingExerciseRepository
@@ -96,7 +108,7 @@ void shouldResetTestCases() throws Exception {
             assertThat(testCase.getWeight()).isEqualTo(1.0);
             assertThat(testCase.getBonusMultiplier()).isEqualTo(1.0);
             assertThat(testCase.getBonusPoints()).isZero();
-            assertThat(testCase.getVisibility()).isEqualTo(Visibility.ALWAYS);
+            assertThat(testCase.getVisibility()).isEqualTo(expectedVisibility);
         }
         assertThat(updatedProgrammingExercise.getTestCasesChanged()).isTrue();
 
diff --git a/src/test/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseFeedbackCreationServiceTest.java b/src/test/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseFeedbackCreationServiceTest.java
index 99ea095a0d5c..0f29e790e235 100644
--- a/src/test/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseFeedbackCreationServiceTest.java
+++ b/src/test/java/de/tum/in/www1/artemis/service/programming/ProgrammingExerciseFeedbackCreationServiceTest.java
@@ -21,7 +21,10 @@
 import de.tum.in.www1.artemis.domain.enumeration.ProgrammingLanguage;
 import de.tum.in.www1.artemis.domain.enumeration.ProjectType;
 import de.tum.in.www1.artemis.domain.enumeration.StaticCodeAnalysisTool;
+import de.tum.in.www1.artemis.domain.enumeration.Visibility;
+import de.tum.in.www1.artemis.domain.exam.ExerciseGroup;
 import de.tum.in.www1.artemis.domain.hestia.ProgrammingExerciseTestCaseType;
+import de.tum.in.www1.artemis.exam.ExamUtilService;
 import de.tum.in.www1.artemis.exercise.programming.ProgrammingExerciseFactory;
 import de.tum.in.www1.artemis.exercise.programming.ProgrammingExerciseUtilService;
 import de.tum.in.www1.artemis.repository.ProgrammingExerciseRepository;
@@ -43,6 +46,9 @@ class ProgrammingExerciseFeedbackCreationServiceTest extends AbstractSpringInteg
     @Autowired
     private ProgrammingExerciseUtilService programmingExerciseUtilService;
 
+    @Autowired
+    private ExamUtilService examUtilService;
+
     private ProgrammingExercise programmingExercise;
 
     @BeforeEach
@@ -274,6 +280,37 @@ void shouldGenerateNewTestCases() {
         assertThat(testCases.stream().allMatch(ProgrammingExerciseTestCase::isActive)).isTrue();
     }
 
+    @Test
+    void shouldGenerateNewTestCasesWithVisibilityAlways() {
+        programmingExercise.setExerciseGroup(null);
+
+        testGenerateNewTestCases(programmingExercise, Visibility.ALWAYS);
+    }
+
+    @Test
+    void shouldGenerateNewTestCasesWithVisibilityAfterDueDate() {
+        ExerciseGroup exerciseGroup1 = examUtilService.addExerciseGroupWithExamAndCourse(true);
+        programmingExercise.setExerciseGroup(exerciseGroup1);
+        programmingExercise = programmingExerciseRepository.save(programmingExercise);
+
+        testGenerateNewTestCases(programmingExercise, Visibility.AFTER_DUE_DATE);
+    }
+
+    private void testGenerateNewTestCases(ProgrammingExercise programmingExercise, Visibility expectedVisibility) {
+        // We do not want to use the test cases generated in the setup
+        testCaseRepository.deleteAll(testCaseRepository.findByExerciseId(programmingExercise.getId()));
+
+        var result = generateResult(List.of("test1", "test2"), Collections.emptyList());
+        feedbackCreationService.generateTestCasesFromBuildResult(result, programmingExercise);
+
+        Set<ProgrammingExerciseTestCase> testCases = testCaseRepository.findByExerciseId(programmingExercise.getId());
+        assertThat(testCases).hasSize(2);
+
+        for (ProgrammingExerciseTestCase testCase : testCases) {
+            assertThat(testCase.getVisibility()).isEqualTo(expectedVisibility);
+        }
+    }
+
     @Test
     void shouldFilterOutDuplicateTestCases() {
         // We do not want to use the test cases generated in the setup
diff --git a/src/test/javascript/spec/component/programming-exercise/programming-exercise-lifecycle.component.spec.ts b/src/test/javascript/spec/component/programming-exercise/programming-exercise-lifecycle.component.spec.ts
index cf5f7bb8a545..b9bbd8e9ad28 100644
--- a/src/test/javascript/spec/component/programming-exercise/programming-exercise-lifecycle.component.spec.ts
+++ b/src/test/javascript/spec/component/programming-exercise/programming-exercise-lifecycle.component.spec.ts
@@ -7,14 +7,15 @@ import { HelpIconComponent } from 'app/shared/components/help-icon.component';
 import { ProgrammingExercise } from 'app/entities/programming-exercise.model';
 import { ProgrammingExerciseTestScheduleDatePickerComponent } from 'app/exercises/programming/shared/lifecycle/programming-exercise-test-schedule-date-picker.component';
 import { NgModel } from '@angular/forms';
-import { TranslatePipeMock } from '../../helpers/mocks/service/mock-translate.service';
 import { AssessmentType } from 'app/entities/assessment-type.model';
 import { QueryList, SimpleChange } from '@angular/core';
 import { IncludedInOverallScore } from 'app/entities/exercise.model';
 import { expectElementToBeDisabled, expectElementToBeEnabled } from '../../helpers/utils/general.utils';
 import { Course } from 'app/entities/course.model';
 import { ExerciseFeedbackSuggestionOptionsComponent } from 'app/exercises/shared/feedback-suggestion/exercise-feedback-suggestion-options.component';
-import { Subject } from 'rxjs';
+import { Subject, of } from 'rxjs';
+import { ActivatedRoute, UrlSegment } from '@angular/router';
+import { TranslatePipeMock } from '../../helpers/mocks/service/mock-translate.service';
 
 describe('ProgrammingExerciseLifecycleComponent', () => {
     let comp: ProgrammingExerciseLifecycleComponent;
@@ -37,6 +38,14 @@ describe('ProgrammingExerciseLifecycleComponent', () => {
                 MockDirective(NgModel),
                 TranslatePipeMock,
             ],
+            providers: [
+                {
+                    provide: ActivatedRoute,
+                    useValue: {
+                        url: of([{ path: 'programming-exercises' }] as UrlSegment[]),
+                    },
+                },
+            ],
         })
             .compileComponents()
             .then(() => {
diff --git a/src/test/javascript/spec/util/shared/utils.spec.ts b/src/test/javascript/spec/util/shared/utils.spec.ts
index 09b5b12695d8..296e7ba1fabc 100644
--- a/src/test/javascript/spec/util/shared/utils.spec.ts
+++ b/src/test/javascript/spec/util/shared/utils.spec.ts
@@ -1,11 +1,14 @@
 import {
     average,
     getAsMutableObject,
+    isExamExercise,
     round,
     roundScorePercentSpecifiedByCourseSettings,
     roundValueSpecifiedByCourseSettings,
     stringifyIgnoringFields,
 } from 'app/shared/util/utils';
+import { Exercise } from 'app/entities/exercise.model';
+import { Course } from 'app/entities/course.model';
 
 describe('Round', () => {
     it('Decimal length', () => {
@@ -95,8 +98,24 @@ describe('getAsMutableObject', () => {
         });
 
         const mutableObject = getAsMutableObject(immutableObject);
-        mutableObject.name = 'Kelly';
+        mutableObject.name = 'Kelly'; // would throw an error if the object was not mutable
         mutableObject.familyName = 'Wilkins';
         mutableObject.age = 42;
     });
 });
+
+describe('isExamExercise', () => {
+    it('should return true if course is not set', () => {
+        const examExercise = { course: undefined } as Exercise;
+
+        const isExamExerciseResult = isExamExercise(examExercise);
+        expect(isExamExerciseResult).toBeTrue();
+    });
+
+    it('should return false if course is set', () => {
+        const courseExercise = { course: new Course() } as Exercise;
+
+        const isExamExerciseResult = isExamExercise(courseExercise);
+        expect(isExamExerciseResult).toBeFalse();
+    });
+});
diff --git a/src/test/playwright/support/pageobjects/exam/ExamExerciseGroupCreationPage.ts b/src/test/playwright/support/pageobjects/exam/ExamExerciseGroupCreationPage.ts
index eede57aaf0e4..065de88a4a9d 100644
--- a/src/test/playwright/support/pageobjects/exam/ExamExerciseGroupCreationPage.ts
+++ b/src/test/playwright/support/pageobjects/exam/ExamExerciseGroupCreationPage.ts
@@ -8,6 +8,7 @@ import { generateUUID } from '../../utils';
 import { QuizExercise } from 'app/entities/quiz/quiz-exercise.model';
 import { ExerciseGroup } from 'app/entities/exercise-group.model';
 import { Exercise } from 'app/entities/exercise.model';
+import { Visibility } from 'app/entities/programming-exercise-test-case.model';
 
 export class ExamExerciseGroupCreationPage {
     private readonly page: Page;
@@ -51,6 +52,12 @@ export class ExamExerciseGroupCreationPage {
             additionalData!.quizExerciseID = quiz.quizQuestions![0].id;
             exercise = { ...quiz, additionalData };
         }
+
+        if (exerciseType === ExerciseType.PROGRAMMING) {
+            const RETRY_NUMBER = 0;
+            await this.exerciseAPIRequests.changeProgrammingExerciseTestVisibility(exercise, Visibility.Always, RETRY_NUMBER);
+        }
+
         return exercise;
     }
 
diff --git a/src/test/playwright/support/requests/ExerciseAPIRequests.ts b/src/test/playwright/support/requests/ExerciseAPIRequests.ts
index 160e26f15b73..2a2d66217380 100644
--- a/src/test/playwright/support/requests/ExerciseAPIRequests.ts
+++ b/src/test/playwright/support/requests/ExerciseAPIRequests.ts
@@ -40,6 +40,18 @@ import { Participation } from 'app/entities/participation/participation.model';
 import { Exam } from 'app/entities/exam.model';
 import { StudentParticipation } from 'app/entities/participation/student-participation.model';
 import { TeamAssignmentConfig } from 'app/entities/team-assignment-config.model';
+import { ProgrammingExerciseTestCase, Visibility } from 'app/entities/programming-exercise-test-case.model';
+
+type PatchProgrammingExerciseTestVisibilityDto = {
+    id: number;
+    weight: number;
+    bonusPoints: number;
+    bonusMultiplier: number;
+    visibility: Visibility;
+}[];
+
+const MAX_RETRIES: number = 20;
+const RETRY_DELAY: number = 3000;
 
 export class ExerciseAPIRequests {
     private readonly page: Page;
@@ -140,6 +152,37 @@ export class ExerciseAPIRequests {
         return response.json();
     }
 
+    /**
+     * Retrieves the test cases for passed exercise and adjusts their visibility according.
+     * <br>
+     * Note: test cases are not available before the tests of the solution have completely run through
+     *       -> we need to do retries until the tests have been executed
+     *
+     * @param programmingExercise for which the test cases shall be set to {@link newVisibility}
+     * @param newVisibility that is applied for all found test cases
+     * @param retryNumber
+     */
+    async changeProgrammingExerciseTestVisibility(programmingExercise: ProgrammingExercise, newVisibility: Visibility, retryNumber: number) {
+        if (retryNumber >= MAX_RETRIES) {
+            throw new Error('Could not find test cases (tests for solution might not be finished yet)');
+        }
+
+        const response = await this.page.request.get(`${PROGRAMMING_EXERCISE_BASE}/${programmingExercise.id}/test-cases`);
+        const testCases = (await response.json()) as unknown as ProgrammingExerciseTestCase[];
+
+        if (retryNumber > 0) {
+            console.log(`Could not find test cases yet, retrying... (${retryNumber} / ${MAX_RETRIES})`);
+        }
+
+        await this.page.waitForTimeout(RETRY_DELAY);
+
+        if (testCases.length > 0) {
+            await this.updateProgrammingExerciseTestCaseVisibility(programmingExercise.id!, testCases, newVisibility);
+        } else {
+            await this.changeProgrammingExerciseTestVisibility(programmingExercise, newVisibility, retryNumber + 1);
+        }
+    }
+
     /**
      * Submits the example submission to the specified repository.
      *
@@ -473,6 +516,26 @@ export class ExerciseAPIRequests {
         return await this.page.request.post(`${EXERCISE_BASE}/${exerciseId}/participations`);
     }
 
+    private async updateProgrammingExerciseTestCaseVisibility(
+        programmingExerciseId: number,
+        programmingExerciseTestCases: ProgrammingExerciseTestCase[],
+        newVisibility: Visibility,
+    ) {
+        const updatedTestCaseSettings: PatchProgrammingExerciseTestVisibilityDto = [];
+
+        for (const testCase of programmingExerciseTestCases) {
+            updatedTestCaseSettings.push({
+                id: testCase.id!,
+                weight: testCase.weight!,
+                bonusPoints: testCase.bonusPoints!,
+                bonusMultiplier: testCase.bonusMultiplier!,
+                visibility: newVisibility,
+            });
+        }
+
+        return await this.page.request.patch(`${PROGRAMMING_EXERCISE_BASE}/${programmingExerciseId}/update-test-cases`, { data: updatedTestCaseSettings });
+    }
+
     private async updateExercise(exercise: Exercise, type: ExerciseType) {
         let url: string;
         switch (type) {
diff --git a/supporting_scripts/course-setup-quickstart/create_course.py b/supporting_scripts/course-setup-quickstart/create_course.py
index fe0862011677..edece49e9fa1 100644
--- a/supporting_scripts/course-setup-quickstart/create_course.py
+++ b/supporting_scripts/course-setup-quickstart/create_course.py
@@ -88,7 +88,7 @@ def create_course(session):
     response = session.post(url, data=body, headers=headers)
 
     if response.status_code == 201:
-        logging.success(f"Created course {course_name} with shortName {course_short_name} \n {response.json()}")
+        logging.info(f"Created course {course_name} with shortName {course_short_name} \n {response.json()}")
     else:
         logging.error("Problem with the group 'students' and interacting with a test server? Is 'is_local_course' in "
                       "'config.ini' set to 'False'?")