diff --git a/test/unit/org/openstreetmap/josm/testutils/annotations/BasicPreferences.java b/test/unit/org/openstreetmap/josm/testutils/annotations/BasicPreferences.java
index 1ee93ed28..0ae4a1479 100644
--- a/test/unit/org/openstreetmap/josm/testutils/annotations/BasicPreferences.java
+++ b/test/unit/org/openstreetmap/josm/testutils/annotations/BasicPreferences.java
@@ -6,6 +6,10 @@ import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Vector;
+import java.util.stream.Collectors;
 
 import org.junit.jupiter.api.extension.AfterAllCallback;
 import org.junit.jupiter.api.extension.AfterEachCallback;
@@ -15,6 +19,7 @@ import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
 import org.openstreetmap.josm.data.Preferences;
+import org.openstreetmap.josm.data.preferences.AbstractProperty;
 import org.openstreetmap.josm.data.preferences.JosmBaseDirectories;
 import org.openstreetmap.josm.data.preferences.JosmUrls;
 import org.openstreetmap.josm.spi.preferences.Config;
@@ -42,6 +47,9 @@ public @interface BasicPreferences {
         @Override
         public void afterAll(ExtensionContext context) throws Exception {
             AnnotationUtils.resetStaticClass(Config.class);
+
+            // Ensure that config tests are consistent
+            resetConfigVariables(null);
         }
 
         @Override
@@ -64,6 +72,8 @@ public @interface BasicPreferences {
 
             // Store the pref for other extensions
             context.getStore(Namespace.create(BasicPreferencesExtension.class)).put("preferences", pref);
+
+            resetConfigVariables(pref);
         }
 
         @Override
@@ -72,5 +82,62 @@ public @interface BasicPreferences {
                 this.beforeAll(context);
             }
         }
+
+        /**
+         * Reset all {@link AbstractProperty} preferences to the new preference
+         * @param pref The preference to use
+         * @throws ReflectiveOperationException if reflection fails
+         */
+        private void resetConfigVariables(Preferences pref) throws ReflectiveOperationException {
+            final Field classField = ClassLoader.class.getDeclaredField("classes");
+            classField.setAccessible(true);
+            final Field configField = AbstractProperty.class.getDeclaredField("preferences");
+            final boolean configIsFinal = Modifier.isFinal(configField.getModifiers());
+            try {
+                if (configIsFinal) {
+                    makeFinalFieldModifiable(configField, true);
+                }
+                // We are pretty much requiring that this doesn't change.
+                @SuppressWarnings("unchecked")
+                Vector<Class<?>> classes = (Vector<Class<?>>) classField.get(this.getClass().getClassLoader());
+                // We need to copy to another list (ConcurrentModificationException)
+                for (Class<?> clazz : classes.stream().collect(Collectors.toList())) {
+                    for (Field field : clazz.getDeclaredFields()) {
+                        if (Modifier.isStatic(field.getModifiers()) && AbstractProperty.class.isInstance(field.getType())) {
+                            configField.set(field.get(null), pref);
+                        }
+                    }
+                }
+            } finally {
+                if (configIsFinal) {
+                    makeFinalFieldModifiable(configField, false);
+                }
+            }
+        }
+
+        /**
+         * Make a final field modifiable. This should always be called twice (once prior to modification, once after)
+         * @param field The field to make modifiable
+         * @param modifiable {@code false} will make the field final
+         * @throws ReflectiveOperationException If the reflection operations fail
+         */
+        private static void makeFinalFieldModifiable(Field field, boolean modifiable) throws ReflectiveOperationException {
+            Field modifiersField = Field.class.getDeclaredField("modifiers");
+            boolean isModifierAccessible = modifiersField.isAccessible();
+            try {
+                if (!isModifierAccessible) {
+                    modifiersField.setAccessible(true);
+                }
+                if (modifiable) {
+                    modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
+                } else {
+                    modifiersField.setInt(field, field.getModifiers() | Modifier.FINAL);
+                }
+            } finally {
+                if (!isModifierAccessible) {
+                    modifiersField.setAccessible(false);
+                }
+            }
+        }
     }
 }