1/* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements.  See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License.  You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package libcore.java.util.prefs;
18
19import java.io.File;
20import java.util.prefs.AbstractPreferences;
21import java.util.prefs.PreferenceChangeEvent;
22import java.util.prefs.PreferenceChangeListener;
23import java.util.prefs.Preferences;
24import java.util.prefs.PreferencesFactory;
25
26import junit.framework.TestCase;
27
28import libcore.io.IoUtils;
29
30public final class OldPreferenceChangeEventTest extends TestCase {
31
32    private PreferencesFactory defaultFactory;
33
34    @Override
35    public void setUp() throws Exception {
36        super.setUp();
37        File tmpDir = IoUtils.createTemporaryDirectory("OldPreferenceChangeEventTest");
38        defaultFactory = Preferences.setPreferencesFactory(
39                new PreferencesTest.TestPreferencesFactory(tmpDir.getAbsolutePath()));
40    }
41
42    @Override
43    public void tearDown() throws Exception {
44        Preferences.setPreferencesFactory(defaultFactory);
45        super.tearDown();
46    }
47
48    public void testGetKey() {
49        AbstractPreferences parent = (AbstractPreferences) Preferences
50                .userNodeForPackage(Preferences.class);
51
52        AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
53
54        MockPreferenceChangeListener pl = new MockPreferenceChangeListener() {
55            public void preferenceChange(PreferenceChangeEvent pce) {
56                if (pce != null && pce.getKey().equals("key_int")) {
57                    result = true;
58                }
59                super.preferenceChange(pce);
60            }
61        };
62        pref.addPreferenceChangeListener(pl);
63        try {
64            pref.putInt("key_int", Integer.MAX_VALUE);
65            assertEquals(1, pl.getChanged());
66            assertTrue(pl.getResult());
67            pl.reset();
68        } finally {
69            pref.removePreferenceChangeListener(pl);
70        }
71    }
72
73    public void testGetNewValue() {
74        AbstractPreferences parent = (AbstractPreferences) Preferences
75                .userNodeForPackage(Preferences.class);
76
77        AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
78
79        MockPreferenceChangeListener pl = new MockPreferenceChangeListener() {
80            public void preferenceChange(PreferenceChangeEvent pce) {
81                if (pce != null && pce.getNewValue().equals(Integer.toString(Integer.MAX_VALUE))) {
82                    result = true;
83                }
84                super.preferenceChange(pce);
85            }
86        };
87        pref.addPreferenceChangeListener(pl);
88        try {
89            pref.putInt("key_int", Integer.MAX_VALUE);
90            assertEquals(1, pl.getChanged());
91            assertTrue(pl.getResult());
92            pl.reset();
93
94            pref.putInt("key_int", Integer.MAX_VALUE);
95            assertEquals(1, pl.getChanged());
96            assertTrue(pl.getResult());
97            pl.reset();
98        } finally {
99            pref.removePreferenceChangeListener(pl);
100        }
101    }
102
103    public void testGetNode() {
104        AbstractPreferences parent = (AbstractPreferences) Preferences
105                .userNodeForPackage(Preferences.class);
106
107        AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
108
109        MockPreferenceChangeListener pl = new MockPreferenceChangeListener() {
110            public void preferenceChange(PreferenceChangeEvent pce) {
111                if (pce != null && "mock".equals(pce.getNode().name())) {
112                    result = true;
113                }
114                super.preferenceChange(pce);
115            }
116        };
117        pref.addPreferenceChangeListener(pl);
118        try {
119            pref.putInt("key_int", Integer.MAX_VALUE);
120            assertEquals(1, pl.getChanged());
121            assertTrue(pl.getResult());
122            pl.reset();
123        } finally {
124            pref.removePreferenceChangeListener(pl);
125        }
126    }
127
128    private static class MockPreferenceChangeListener implements PreferenceChangeListener {
129        private int changed = 0;
130        private boolean addDispatched = false;
131        protected boolean result = false;
132
133        public synchronized void waitForEvent() {
134            try {
135                wait(500);
136            } catch (InterruptedException expected) {
137            }
138        }
139
140        public synchronized void preferenceChange(PreferenceChangeEvent pce) {
141            changed++;
142            addDispatched = true;
143            notifyAll();
144        }
145
146        public synchronized boolean getResult() {
147            if (!addDispatched) {
148                try {
149                    // TODO: don't know why must add limitation
150                    this.wait(100);
151                } catch (InterruptedException e) {
152                    e.printStackTrace();
153                }
154            }
155            addDispatched = false;
156            return result;
157        }
158
159        public synchronized int getChanged() {
160            if (!addDispatched) {
161                try {
162                    // TODO: don't know why must add limitation
163                    this.wait(1000);
164                } catch (InterruptedException e) {
165                    e.printStackTrace();
166                }
167            }
168            addDispatched = false;
169            return changed;
170        }
171
172        public void reset() {
173            changed = 0;
174            result = false;
175        }
176    }
177}
178