Fake Shared Preferences class that uses an in-memory implementation

FakePreferences.kt

class FakePreferences : SharedPreferences {

    private val map: MutableMap<String, Any?> = mutableMapOf()
    private val listeners: MutableList<SharedPreferences.OnSharedPreferenceChangeListener> = mutableListOf()

    override fun getAll(): MutableMap<String, *> = map
    override fun getString(key: String, default: String?): String? = map[key] as String? ?: default

    @Suppress("UNCHECKED_CAST")
    override fun getStringSet(key: String, default: MutableSet<String>?): MutableSet<String>? =
        map[key] as MutableSet<String>? ?: default

    override fun getInt(key: String, default: Int): Int = map[key] as Int? ?: default
    override fun getLong(key: String, default: Long): Long = map[key] as Long? ?: default
    override fun getFloat(key: String, default: Float): Float = map[key] as Float? ?: default
    override fun getBoolean(key: String, default: Boolean): Boolean = map[key] as Boolean? ?: default
    override fun contains(key: String): Boolean = map.containsKey(key)
    override fun edit(): SharedPreferences.Editor = FakePreferencesEditor()
    override fun registerOnSharedPreferenceChangeListener(listener: SharedPreferences.OnSharedPreferenceChangeListener) {
        listeners.add(listener)
    }

    override fun unregisterOnSharedPreferenceChangeListener(listener: SharedPreferences.OnSharedPreferenceChangeListener) {
        listeners.remove(listener)
    }

    private inner class FakePreferencesEditor : SharedPreferences.Editor {

        private val keysChanges: MutableList<String> = mutableListOf()
        private var temporaryMap: MutableMap<String, Any?> = mutableMapOf<String, Any?>().apply {
            putAll(map)
        }

        override fun putString(key: String, value: String?): SharedPreferences.Editor {
            temporaryMap[key] = value
            keysChanges.add(key)
            return this
        }

        override fun putStringSet(key: String, value: MutableSet<String>?): SharedPreferences.Editor {
            temporaryMap[key] = value
            keysChanges.add(key)
            return this
        }

        override fun putInt(key: String, value: Int): SharedPreferences.Editor {
            temporaryMap[key] = value
            keysChanges.add(key)
            return this
        }

        override fun putLong(key: String, value: Long): SharedPreferences.Editor {
            temporaryMap[key] = value
            keysChanges.add(key)
            return this
        }

        override fun putFloat(key: String, value: Float): SharedPreferences.Editor {
            temporaryMap[key] = value
            keysChanges.add(key)
            return this
        }

        override fun putBoolean(key: String, value: Boolean): SharedPreferences.Editor {
            temporaryMap[key] = value
            keysChanges.add(key)
            return this
        }

        override fun remove(key: String): SharedPreferences.Editor {
            temporaryMap.remove(key)
            keysChanges.add(key)
            return this
        }

        override fun clear(): SharedPreferences.Editor {
            temporaryMap.clear()
            keysChanges.addAll(map.keys)
            return this
        }

        override fun commit(): Boolean {
            apply()
            return true
        }

        override fun apply() {
            map.clear()
            map.putAll(temporaryMap)
            listeners.forEach { listener ->
                keysChanges.forEach { key ->
                    listener.onSharedPreferenceChanged(this@FakePreferences, key)
                }
            }
            keysChanges.clear()
        }
    }
}