root/base/test/android/javatests/src/org/chromium/base/test/util/InMemorySharedPreferences.java

DEFINITIONS

1. getAll
2. getString
3. SuppressWarnings
4. getStringSet
5. getInt
6. getLong
7. getFloat
8. getBoolean
9. contains
10. edit
11. registerOnSharedPreferenceChangeListener
12. unregisterOnSharedPreferenceChangeListener
13. putString
14. putStringSet
15. putInt
16. putLong
17. putFloat
18. putBoolean
19. remove
20. clear
21. commit
22. apply

// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package org.chromium.base.test.util;

import android.content.SharedPreferences;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * An implementation of SharedPreferences that can be used in tests.
 * <p/>
 * It keeps all state in memory, and there is no difference between apply() and commit().
 */
public class InMemorySharedPreferences implements SharedPreferences {

    // Guarded on its own monitor.
    private final Map<String, Object> mData;

    public InMemorySharedPreferences() {
        mData = new HashMap<String, Object>();
    }

    public InMemorySharedPreferences(Map<String, Object> data) {
        mData = data;
    }

    @Override
    public Map<String, ?> getAll() {
        synchronized (mData) {
            return Collections.unmodifiableMap(mData);
        }
    }

    @Override
    public String getString(String key, String defValue) {
        synchronized (mData) {
            if (mData.containsKey(key)) {
                return (String) mData.get(key);
            }
        }
        return defValue;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Set<String> getStringSet(String key, Set<String> defValues) {
        synchronized (mData) {
            if (mData.containsKey(key)) {
                return Collections.unmodifiableSet((Set<String>) mData.get(key));
            }
        }
        return defValues;
    }

    @Override
    public int getInt(String key, int defValue) {
        synchronized (mData) {
            if (mData.containsKey(key)) {
                return (Integer) mData.get(key);
            }
        }
        return defValue;
    }

    @Override
    public long getLong(String key, long defValue) {
        synchronized (mData) {
            if (mData.containsKey(key)) {
                return (Long) mData.get(key);
            }
        }
        return defValue;
    }

    @Override
    public float getFloat(String key, float defValue) {
        synchronized (mData) {
            if (mData.containsKey(key)) {
                return (Float) mData.get(key);
            }
        }
        return defValue;
    }

    @Override
    public boolean getBoolean(String key, boolean defValue) {
        synchronized (mData) {
            if (mData.containsKey(key)) {
                return (Boolean) mData.get(key);
            }
        }
        return defValue;
    }

    @Override
    public boolean contains(String key) {
        synchronized (mData) {
            return mData.containsKey(key);
        }
    }

    @Override
    public SharedPreferences.Editor edit() {
        return new InMemoryEditor();
    }

    @Override
    public void registerOnSharedPreferenceChangeListener(
            SharedPreferences.OnSharedPreferenceChangeListener
                    listener) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void unregisterOnSharedPreferenceChangeListener(
            SharedPreferences.OnSharedPreferenceChangeListener listener) {
        throw new UnsupportedOperationException();
    }

    private class InMemoryEditor implements SharedPreferences.Editor {

        // All guarded by |mChanges|
        private boolean mClearCalled;
        private volatile boolean mApplyCalled;
        private final Map<String, Object> mChanges = new HashMap<String, Object>();

        @Override
        public SharedPreferences.Editor putString(String key, String value) {
            synchronized (mChanges) {
                if (mApplyCalled) throw new IllegalStateException();
                mChanges.put(key, value);
                return this;
            }
        }

        @Override
        public SharedPreferences.Editor putStringSet(String key, Set<String> values) {
            synchronized (mChanges) {
                if (mApplyCalled) throw new IllegalStateException();
                mChanges.put(key, values);
                return this;
            }
        }

        @Override
        public SharedPreferences.Editor putInt(String key, int value) {
            synchronized (mChanges) {
                if (mApplyCalled) throw new IllegalStateException();
                mChanges.put(key, value);
                return this;
            }
        }

        @Override
        public SharedPreferences.Editor putLong(String key, long value) {
            synchronized (mChanges) {
                if (mApplyCalled) throw new IllegalStateException();
                mChanges.put(key, value);
                return this;
            }
        }

        @Override
        public SharedPreferences.Editor putFloat(String key, float value) {
            synchronized (mChanges) {
                if (mApplyCalled) throw new IllegalStateException();
                mChanges.put(key, value);
                return this;
            }
        }

        @Override
        public SharedPreferences.Editor putBoolean(String key, boolean value) {
            synchronized (mChanges) {
                if (mApplyCalled) throw new IllegalStateException();
                mChanges.put(key, value);
                return this;
            }
        }

        @Override
        public SharedPreferences.Editor remove(String key) {
            synchronized (mChanges) {
                if (mApplyCalled) throw new IllegalStateException();
                // Magic value for removes
                mChanges.put(key, this);
                return this;
            }
        }

        @Override
        public SharedPreferences.Editor clear() {
            synchronized (mChanges) {
                if (mApplyCalled) throw new IllegalStateException();
                mClearCalled = true;
                return this;
            }
        }

        @Override
        public boolean commit() {
            apply();
            return true;
        }

        @Override
        public void apply() {
            synchronized (mData) {
                synchronized (mChanges) {
                    if (mApplyCalled) throw new IllegalStateException();
                    if (mClearCalled) {
                        mData.clear();
                    }
                    for (Map.Entry<String, Object> entry : mChanges.entrySet()) {
                        String key = entry.getKey();
                        Object value = entry.getValue();
                        if (value == this) {
                            // Special value for removal
                            mData.remove(key);
                        } else {
                            mData.put(key, value);
                        }
                    }
                    // The real shared prefs clears out the temporaries allowing the caller to
                    // reuse the Editor instance, however this is undocumented behavior and subtle
                    // to read, so instead we just ban any future use of this instance.
                    mApplyCalled = true;
                }
            }
        }
    }

}