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 org.apache.harmony.prefs.tests.java.util.prefs;
18
19import java.io.ByteArrayInputStream;
20import java.io.IOException;
21import java.io.InputStream;
22import java.io.OutputStream;
23import java.net.MalformedURLException;
24import java.util.prefs.AbstractPreferences;
25import java.util.prefs.BackingStoreException;
26import java.util.prefs.InvalidPreferencesFormatException;
27import java.util.prefs.NodeChangeListener;
28import java.util.prefs.PreferenceChangeListener;
29import java.util.prefs.Preferences;
30
31import junit.framework.TestCase;
32
33/**
34 *
35 */
36public class PreferencesTest extends TestCase {
37
38    MockInputStream stream = null;
39
40    InputStream in;
41
42    /*
43     * @see TestCase#setUp()
44     */
45    @Override
46    protected void setUp() throws Exception {
47        super.setUp();
48        in = new ByteArrayInputStream("<!DOCTYPE preferences SYSTEM \"http://java.sun.com/dtd/preferences.dtd\"><preferences><root type=\"user\"><map></map></root></preferences>".getBytes("UTF-8"));
49        stream = new MockInputStream(in);
50    }
51
52    /*
53     * @see TestCase#tearDown()
54     */
55    @Override
56    protected void tearDown() throws Exception {
57        super.tearDown();
58        stream.close();
59    }
60
61    public void testSystemNodeForPackage() throws BackingStoreException {
62        Preferences p = null;
63        try {
64            p = Preferences.systemNodeForPackage(Object.class);
65        } catch (SecurityException e) {
66            // may be caused by absence of privileges on the underlying OS
67            return;
68        }
69        assertEquals("/java/lang", p.absolutePath());
70        assertTrue(p instanceof AbstractPreferences);
71        Preferences root = Preferences.systemRoot();
72        Preferences parent = root.node("java");
73        assertSame(parent, p.parent());
74        assertFalse(p.isUserNode());
75        assertEquals("lang", p.name());
76        assertEquals("System Preference Node: " + p.absolutePath(), p
77                .toString());
78
79        assertEquals(0, p.childrenNames().length);
80        assertEquals(0, p.keys().length);
81        parent.removeNode();
82        try {
83            Preferences.userNodeForPackage(null);
84            fail("should throw NullPointerException");
85        } catch (NullPointerException e) {
86            // Expected
87        }
88    }
89
90    public void testSystemRoot() throws BackingStoreException {
91        Preferences p = Preferences.systemRoot();
92        assertTrue(p instanceof AbstractPreferences);
93        assertEquals("/", p.absolutePath());
94        assertSame(null, p.parent());
95        assertFalse(p.isUserNode());
96        assertEquals("", p.name());
97        assertEquals("System Preference Node: " + p.absolutePath(), p
98                .toString());
99    }
100
101    public void testConsts() {
102        assertEquals(80, Preferences.MAX_KEY_LENGTH);
103        assertEquals(80, Preferences.MAX_NAME_LENGTH);
104        assertEquals(8192, Preferences.MAX_VALUE_LENGTH);
105    }
106
107    public void testUserNodeForPackage() throws BackingStoreException {
108        Preferences p = Preferences.userNodeForPackage(Object.class);
109        assertEquals("/java/lang", p.absolutePath());
110        assertTrue(p instanceof AbstractPreferences);
111        Preferences root = Preferences.userRoot();
112        Preferences parent = root.node("java");
113        assertSame(parent, p.parent());
114        assertTrue(p.isUserNode());
115        assertEquals("lang", p.name());
116        assertEquals("User Preference Node: " + p.absolutePath(), p.toString());
117        assertEquals(0, p.childrenNames().length);
118        assertEquals(0, p.keys().length);
119
120        try {
121            Preferences.userNodeForPackage(null);
122            fail("should throw NullPointerException");
123        } catch (NullPointerException e) {
124            // Expected
125        }
126    }
127
128    public void testUserRoot() throws BackingStoreException {
129        Preferences p = Preferences.userRoot();
130        assertTrue(p instanceof AbstractPreferences);
131        assertEquals("/", p.absolutePath());
132        assertSame(null, p.parent());
133        assertTrue(p.isUserNode());
134        assertEquals("", p.name());
135        assertEquals("User Preference Node: " + p.absolutePath(), p.toString());
136    }
137
138    public void testImportPreferences() throws Exception {
139        Preferences prefs = null;
140        try {
141            prefs = Preferences.userNodeForPackage(PreferencesTest.class);
142            // assertEquals(0, prefs.childrenNames().length);
143            // assertFalse(prefs.nodeExists("mock/child/grandson"));
144
145            prefs.put("prefskey", "oldvalue");
146            prefs.put("prefskey2", "oldvalue2");
147            in = PreferencesTest.class
148                    .getResourceAsStream("/prefs/java/util/prefs/userprefs.xml");
149            Preferences.importPreferences(in);
150
151            prefs = Preferences.userNodeForPackage(PreferencesTest.class);
152            assertEquals(1, prefs.childrenNames().length);
153            assertTrue(prefs.nodeExists("mock/child/grandson"));
154            assertEquals("newvalue", prefs.get("prefskey", null));
155            assertEquals("oldvalue2", prefs.get("prefskey2", null));
156            assertEquals("newvalue3", prefs.get("prefskey3", null));
157
158            in = PreferencesTest.class
159                    .getResourceAsStream("/prefs/java/util/prefs/userprefs-badform.xml");
160            try {
161                Preferences.importPreferences(in);
162                fail("should throw InvalidPreferencesFormatException");
163            } catch (InvalidPreferencesFormatException e) {
164                // Expected
165            }
166
167            in = PreferencesTest.class
168                    .getResourceAsStream("/prefs/java/util/prefs/userprefs-badtype.xml");
169            try {
170                Preferences.importPreferences(in);
171                fail("should throw InvalidPreferencesFormatException");
172            } catch (InvalidPreferencesFormatException e) {
173                // Expected
174            }
175
176            in = PreferencesTest.class
177                    .getResourceAsStream("/prefs/java/util/prefs/userprefs-badencoding.xml");
178            try {
179                Preferences.importPreferences(in);
180                fail("should throw InvalidPreferencesFormatException");
181            } catch (InvalidPreferencesFormatException e) {
182                // Expected
183            }
184
185            in = PreferencesTest.class
186                    .getResourceAsStream("/prefs/java/util/prefs/userprefs-higherversion.xml");
187            try {
188                Preferences.importPreferences(in);
189                fail("should throw InvalidPreferencesFormatException");
190            } catch (InvalidPreferencesFormatException e) {
191                // Expected
192            }
193
194            in = PreferencesTest.class
195                    .getResourceAsStream("/prefs/java/util/prefs/userprefs-ascii.xml");
196            Preferences.importPreferences(in);
197            prefs = Preferences.userNodeForPackage(PreferencesTest.class);
198        } finally {
199            try {
200                prefs = Preferences.userNodeForPackage(PreferencesTest.class);
201                prefs.removeNode();
202            } catch (Exception e) {
203                // Ignored
204            }
205        }
206    }
207
208    public void testImportPreferencesException() throws Exception {
209        try {
210            Preferences.importPreferences(null);
211            fail("should throw MalformedURLException");
212        } catch (MalformedURLException e) {
213            // Expected
214        }
215
216        byte[] source = new byte[0];
217        InputStream in = new ByteArrayInputStream(source);
218        try {
219            Preferences.importPreferences(in);
220            fail("should throw InvalidPreferencesFormatException");
221        } catch (InvalidPreferencesFormatException e) {
222            // Expected
223        }
224
225        stream.setResult(MockInputStream.exception);
226        try {
227            Preferences.importPreferences(stream);
228            fail("should throw IOException");
229        } catch (IOException e) {
230            // Expected
231        }
232
233        stream.setResult(MockInputStream.runtimeException);
234        try {
235            Preferences.importPreferences(stream);
236            fail("should throw RuntimeException");
237        } catch (RuntimeException e) {
238            // Expected
239        }
240    }
241
242    static class MockInputStream extends InputStream {
243
244        static final int normal = 0;
245
246        static final int exception = 1;
247
248        static final int runtimeException = 2;
249
250        int result = normal;
251
252        InputStream wrapper;
253
254        public void setResult(int i) {
255            result = i;
256        }
257
258        private void checkException() throws IOException {
259            switch (result) {
260            case normal:
261                return;
262            case exception:
263                throw new IOException("test");
264            case runtimeException:
265                throw new RuntimeException("test");
266            }
267        }
268
269        public MockInputStream(InputStream in) {
270            wrapper = in;
271        }
272
273        @Override
274        public int read() throws IOException {
275            checkException();
276            return wrapper.read();
277        }
278    }
279
280    static class MockPreferences extends Preferences {
281
282        public MockPreferences() {
283            super();
284        }
285
286        @Override
287        public String absolutePath() {
288            return null;
289        }
290
291        @Override
292        public String[] childrenNames() throws BackingStoreException {
293            return null;
294        }
295
296        @Override
297        public void clear() throws BackingStoreException {
298        }
299
300        @Override
301        public void exportNode(OutputStream ostream) throws IOException,
302        BackingStoreException {
303        }
304
305        @Override
306        public void exportSubtree(OutputStream ostream) throws IOException,
307        BackingStoreException {
308        }
309
310        @Override
311        public void flush() throws BackingStoreException {
312        }
313
314        @Override
315        public String get(String key, String deflt) {
316            return null;
317        }
318
319        @Override
320        public boolean getBoolean(String key, boolean deflt) {
321            return false;
322        }
323
324        @Override
325        public byte[] getByteArray(String key, byte[] deflt) {
326            return null;
327        }
328
329        @Override
330        public double getDouble(String key, double deflt) {
331            return 0;
332        }
333
334        @Override
335        public float getFloat(String key, float deflt) {
336            return 0;
337        }
338
339        @Override
340        public int getInt(String key, int deflt) {
341            return 0;
342        }
343
344        @Override
345        public long getLong(String key, long deflt) {
346            return 0;
347        }
348
349        @Override
350        public boolean isUserNode() {
351            return false;
352        }
353
354        @Override
355        public String[] keys() throws BackingStoreException {
356            return null;
357        }
358
359        @Override
360        public String name() {
361            return null;
362        }
363
364        @Override
365        public Preferences node(String name) {
366            return null;
367        }
368
369        @Override
370        public boolean nodeExists(String name) throws BackingStoreException {
371            return false;
372        }
373
374        @Override
375        public Preferences parent() {
376            return null;
377        }
378
379        @Override
380        public void put(String key, String value) {
381
382        }
383
384        @Override
385        public void putBoolean(String key, boolean value) {
386
387        }
388
389        @Override
390        public void putByteArray(String key, byte[] value) {
391
392        }
393
394        @Override
395        public void putDouble(String key, double value) {
396
397        }
398
399        @Override
400        public void putFloat(String key, float value) {
401
402        }
403
404        @Override
405        public void putInt(String key, int value) {
406
407        }
408
409        @Override
410        public void putLong(String key, long value) {
411
412        }
413
414        @Override
415        public void remove(String key) {
416
417        }
418
419        @Override
420        public void removeNode() throws BackingStoreException {
421
422        }
423
424        @Override
425        public void addNodeChangeListener(NodeChangeListener ncl) {
426
427        }
428
429        @Override
430        public void addPreferenceChangeListener(PreferenceChangeListener pcl) {
431
432        }
433
434        @Override
435        public void removeNodeChangeListener(NodeChangeListener ncl) {
436
437        }
438
439        @Override
440        public void removePreferenceChangeListener(PreferenceChangeListener pcl) {
441
442        }
443
444        @Override
445        public void sync() throws BackingStoreException {
446
447        }
448
449        @Override
450        public String toString() {
451            return null;
452        }
453
454    }
455
456}
457