ProviderTest.java revision cec4dd4b1d33f78997603d0f89c0d0e56e64dbcd 
1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17
18/**
19 * @author Boris V. Kuznetsov
20 * @version $Revision$
21 */
22
23package org.apache.harmony.security.tests.java.security;
24
25import java.io.ByteArrayInputStream;
26import java.io.ByteArrayOutputStream;
27import java.io.IOException;
28import java.io.InputStream;
29import java.io.PrintStream;
30import java.security.NoSuchAlgorithmException;
31import java.security.Permission;
32import java.security.Provider;
33import java.security.Security;
34import java.security.SecurityPermission;
35import java.security.Provider.Service;
36import java.util.Collection;
37import java.util.HashMap;
38import java.util.Iterator;
39import java.util.Map;
40import java.util.Set;
41import java.util.Map.Entry;
42
43import junit.framework.TestCase;
44import dalvik.annotation.KnownFailure;
45import dalvik.annotation.TestLevel;
46import dalvik.annotation.TestTargetClass;
47import dalvik.annotation.TestTargetNew;
48
49@TestTargetClass(Provider.class)
50/**
51 * Tests for <code>Provider</code> constructor and methods
52 *
53 */
54public class ProviderTest extends TestCase {
55    /*
56     * Implementation note: The algorithm name ASH-1 might seem a bit strange,
57     * but since the algorithms cannot be uninstalled anymore we need to make
58     * sure there are not side-effects on other tests. Simply inserting SHA-1
59     * destroys the existing provider infrastructure.
60     */
61
62    Provider[] storedProviders;
63
64    Provider p;
65
66    /*
67     * @see TestCase#setUp()
68     */
69    protected void setUp() throws Exception {
70        super.setUp();
71
72        storedProviders = Security.getProviders();
73
74        p = new MyProvider();
75    }
76
77    @Override
78    protected void tearDown() throws Exception {
79        System.setSecurityManager(null);
80
81        p.remove("MessageDigest.ASH-1");
82        p.remove("MessageDigest.abc");
83        p.remove("Alg.Alias.MessageDigest.ASH1");
84
85        for (Provider p: Security.getProviders()) {
86            Security.removeProvider(p.getName());
87        }
88
89        for (Provider p: storedProviders) {
90            Security.addProvider(p);
91        }
92
93        super.tearDown();
94    }
95
96    /*
97     * Class under test for void Provider()
98     */
99    @TestTargetNew(
100        level = TestLevel.PARTIAL_COMPLETE,
101        notes = "Verifies provider object",
102        method = "Provider",
103        args = {java.lang.String.class, double.class, java.lang.String.class}
104    )
105    public final void testProvider() {
106        if (!p.getProperty("Provider.id name").equals(
107                String.valueOf(p.getName()))) {
108            fail("Incorrect \"Provider.id name\" value");
109        }
110        if (!p.getProperty("Provider.id version").equals(
111                String.valueOf(p.getVersion()))) {
112            fail("Incorrect \"Provider.id version\" value");
113        }
114        if (!p.getProperty("Provider.id info").equals(
115                String.valueOf(p.getInfo()))) {
116            fail("Incorrect \"Provider.id info\" value");
117        }
118        if (!p.getProperty("Provider.id className").equals(
119                p.getClass().getName())) {
120            fail("Incorrect \"Provider.id className\" value");
121        }
122    }
123
124    @TestTargetNew(
125        level = TestLevel.PARTIAL_COMPLETE,
126        notes = "",
127        method = "clear",
128        args = {}
129    )
130    public final void testClear() {
131        p.clear();
132        assertNull(p.getProperty("MessageDigest.SHA-1"));
133    }
134
135    /*
136     * Class under test for void Provider(String, double, String)
137     */
138    @TestTargetNew(
139        level = TestLevel.PARTIAL_COMPLETE,
140        notes = "Verifies constructor with non null parameters",
141        method = "Provider",
142        args = {java.lang.String.class, double.class, java.lang.String.class}
143    )
144    public final void testProviderStringdoubleString() {
145        Provider p = new MyProvider("Provider name", 123.456, "Provider info");
146        assertEquals("Provider name", p.getName());
147        assertEquals(123.456, p.getVersion(), 0L);
148        assertEquals("Provider info", p.getInfo());
149    }
150
151    public final void testGetName() {
152        assertEquals("MyProvider", p.getName());
153    }
154
155    @TestTargetNew(
156        level = TestLevel.COMPLETE,
157        notes = "",
158        method = "getVersion",
159        args = {}
160    )
161    public final void testGetVersion() {
162        assertEquals(1.0, p.getVersion(), 0L);
163    }
164
165    @TestTargetNew(
166        level = TestLevel.COMPLETE,
167        notes = "",
168        method = "getInfo",
169        args = {}
170    )
171    public final void testGetInfo() {
172        assertEquals("Provider for testing", p.getInfo());
173    }
174
175    /*
176     * Class under test for void putAll(Map)
177     */
178    @TestTargetNew(
179        level = TestLevel.COMPLETE,
180        notes = "",
181        method = "putAll",
182        args = {java.util.Map.class}
183    )
184    public final void testPutAllMap() {
185        HashMap hm = new HashMap();
186        hm.put("MessageDigest.SHA-1", "aaa.bbb.ccc.ddd");
187        hm.put("Property 1", "value 1");
188        hm.put("serviceName.algName attrName", "attrValue");
189        hm.put("Alg.Alias.engineClassName.aliasName", "standardName");
190        p.putAll(hm);
191        if (!"value 1".equals(p.getProperty("Property 1").trim()) ||
192                !"attrValue".equals(p.getProperty("serviceName.algName attrName").trim()) ||
193                !"standardName".equals(p.getProperty("Alg.Alias.engineClassName.aliasName").trim()) ||
194                !"aaa.bbb.ccc.ddd".equals(p.getProperty("MessageDigest.SHA-1").trim()) ) {
195            fail("Incorrect property value");
196        }
197    }
198
199    /*
200     * Class under test for Set entrySet()
201     */
202    @TestTargetNew(
203        level = TestLevel.PARTIAL_COMPLETE,
204        notes = "",
205        method = "entrySet",
206        args = {}
207    )
208    public final void testEntrySet() {
209        p.put("MessageDigest.SHA-256", "aaa.bbb.ccc.ddd");
210
211        Set s = p.entrySet();
212        try {
213            s.clear();
214            fail("Must return unmodifiable set");
215        } catch (UnsupportedOperationException e) {
216        }
217
218        assertEquals("Incorrect set size", 8, s.size());
219
220        for (Iterator it = s.iterator(); it.hasNext();) {
221            Entry e = (Entry)it.next();
222            String key = (String)e.getKey();
223            String val = (String)e.getValue();
224            if (key.equals("MessageDigest.SHA-1") && val.equals("SomeClassName")) {
225                continue;
226            }
227            if (key.equals("Alg.Alias.MessageDigest.SHA1") && val.equals("SHA-1")) {
228                continue;
229            }
230            if (key.equals("MessageDigest.abc") && val.equals("SomeClassName")) {
231                continue;
232            }
233            if (key.equals("Provider.id className") && val.equals(p.getClass().getName())) {
234                continue;
235            }
236            if (key.equals("Provider.id name") && val.equals("MyProvider")) {
237                continue;
238            }
239            if (key.equals("MessageDigest.SHA-256") && val.equals("aaa.bbb.ccc.ddd")) {
240                continue;
241            }
242            if (key.equals("Provider.id version") && val.equals("1.0")) {
243                continue;
244            }
245            if (key.equals("Provider.id info") && val.equals("Provider for testing")) {
246                continue;
247            }
248            fail("Incorrect set");
249        }
250    }
251
252    /*
253     * Class under test for Set keySet()
254     */
255    @TestTargetNew(
256        level = TestLevel.COMPLETE,
257        notes = "",
258        method = "keySet",
259        args = {}
260    )
261    public final void testKeySet() {
262        p.put("MessageDigest.SHA-256", "aaa.bbb.ccc.ddd");
263
264        Set<Object> s = p.keySet();
265        try {
266            s.clear();
267        } catch (UnsupportedOperationException e) {
268        }
269        Set s1 = p.keySet();
270
271        assertNotSame(s, s1);
272        assertFalse(s1.isEmpty());
273        assertEquals(8, s1.size());
274
275        assertTrue(s1.contains("MessageDigest.SHA-256"));
276        assertTrue(s1.contains("MessageDigest.SHA-1"));
277        assertTrue(s1.contains("Alg.Alias.MessageDigest.SHA1"));
278        assertTrue(s1.contains("MessageDigest.abc"));
279        assertTrue(s1.contains("Provider.id info"));
280        assertTrue(s1.contains("Provider.id className"));
281        assertTrue(s1.contains("Provider.id version"));
282        assertTrue(s1.contains("Provider.id name"));
283    }
284
285    /*
286     * Class under test for Collection values()
287     */
288    @TestTargetNew(
289        level = TestLevel.PARTIAL_COMPLETE,
290        notes = "",
291        method = "values",
292        args = {}
293    )
294    public final void testValues() {
295        p.put("MessageDigest.ASH-256", "aaa.bbb.ccc.ddd");
296
297        Collection<Object> c = p.values();
298        try {
299            c.clear();
300        } catch (UnsupportedOperationException e) {
301        }
302        Collection c1 = p.values();
303
304        assertNotSame(c, c1);
305        assertFalse(c1.isEmpty());
306        assertEquals(8, c1.size());
307
308        assertTrue(c1.contains("MyProvider"));
309        assertTrue(c1.contains("aaa.bbb.ccc.ddd"));
310        assertTrue(c1.contains("Provider for testing"));
311        assertTrue(c1.contains("1.0"));
312        assertTrue(c1.contains("SomeClassName"));
313        assertTrue(c1.contains("SHA-1"));
314        assertTrue(c1.contains(p.getClass().getName()));
315    }
316
317    /*
318     * Class under test for Object put(Object, Object)
319     */
320    @TestTargetNew(
321        level = TestLevel.PARTIAL_COMPLETE,
322        notes = "",
323        method = "put",
324        args = {java.lang.Object.class, java.lang.Object.class}
325    )
326    public final void testPutObjectObject() {
327        p.put("MessageDigest.SHA-1", "aaa.bbb.ccc.ddd");
328        p.put("Type.Algorithm", "className");
329        assertEquals("aaa.bbb.ccc.ddd", p.getProperty("MessageDigest.SHA-1")
330                .trim());
331
332        Set services = p.getServices();
333        assertEquals(3, services.size());
334
335        for (Iterator it = services.iterator(); it.hasNext();) {
336            Provider.Service s = (Provider.Service)it.next();
337            if ("Type".equals(s.getType()) &&
338                    "Algorithm".equals(s.getAlgorithm()) &&
339                    "className".equals(s.getClassName())) {
340                continue;
341            }
342            if ("MessageDigest".equals(s.getType()) &&
343                    "SHA-1".equals(s.getAlgorithm()) &&
344                    "aaa.bbb.ccc.ddd".equals(s.getClassName())) {
345                continue;
346            }
347            if ("MessageDigest".equals(s.getType()) &&
348                    "abc".equals(s.getAlgorithm()) &&
349                    "SomeClassName".equals(s.getClassName())) {
350                continue;
351            }
352            fail("Incorrect service");
353        }
354    }
355
356    /*
357     * Class under test for Object remove(Object)
358     */
359    @TestTargetNew(
360        level = TestLevel.COMPLETE,
361        notes = "",
362        method = "remove",
363        args = {java.lang.Object.class}
364    )
365    public final void testRemoveObject() {
366        Object o = p.remove("MessageDigest.SHA-1");
367
368        assertEquals("SomeClassName", o);
369        assertNull(p.getProperty("MessageDigest.SHA-1"));
370        assertEquals(1, p.getServices().size());
371    }
372
373    public final void testService1() {
374        p.put("MessageDigest.SHA-1", "AnotherClassName");
375        Provider.Service s = p.getService("MessageDigest", "SHA-1");
376
377        assertEquals("AnotherClassName", s.getClassName());
378    }
379
380    // Regression for HARMONY-2760.
381    @TestTargetNew(
382        level = TestLevel.PARTIAL_COMPLETE,
383        notes = "Regression test: verifies constructor with two null parameters.",
384        method = "Provider",
385        args = {java.lang.String.class, double.class, java.lang.String.class}
386    )
387    public void testConstructor() {
388        MyProvider myProvider = new MyProvider(null, 1, null);
389        assertNull(myProvider.getName());
390        assertNull(myProvider.getInfo());
391        assertEquals("null", myProvider.getProperty("Provider.id name"));
392        assertEquals("null", myProvider.getProperty("Provider.id info"));
393    }
394
395    class MyProvider extends Provider {
396        MyProvider() {
397            super("MyProvider", 1.0, "Provider for testing");
398            put("MessageDigest.SHA-1", "SomeClassName");
399            put("MessageDigest.abc", "SomeClassName");
400            put("Alg.Alias.MessageDigest.SHA1", "SHA-1");
401        }
402
403        MyProvider(String name, double version, String info) {
404            super(name, version, info);
405        }
406
407        // BEGIN android-added
408        public void putService(Provider.Service s) {
409            super.putService(s);
410        }
411        // END android-added
412
413        // BEGIN android-added
414        public void removeService(Provider.Service s) {
415            super.removeService(s);
416        }
417        // END android-added
418
419        // BEGIN android-added
420        public int getNumServices() {
421            return getServices().size();
422        }
423        // END android-added
424    }
425
426    // BEGIN android-added
427    @TestTargetNew(
428            level = TestLevel.PARTIAL_COMPLETE,
429            notes = "",
430            method = "clear",
431            args = {}
432        )
433    public final void testClear_SecurityManager() {
434        TestSecurityManager sm = new TestSecurityManager("clearProviderProperties.MyProvider");
435        System.setSecurityManager(sm);
436        p.clear();
437        assertTrue("Provider.clear must call checkPermission with "
438                + "SecurityPermission clearProviderProperties.NAME",
439                sm.called);
440        System.setSecurityManager(null);
441    }
442    // END android-added
443
444    // BEGIN android-added
445    @TestTargetNew(
446            level = TestLevel.PARTIAL_COMPLETE,
447            notes = "",
448            method = "put",
449            args = {java.lang.Object.class, java.lang.Object.class}
450        )
451    public final void testPutObjectObject_SecurityManager() {
452
453        TestSecurityManager sm = new TestSecurityManager("putProviderProperty.MyProvider");
454        Provider p = new MyProvider();
455        System.setSecurityManager(sm);
456        p.put(new Object(), new Object());
457        assertTrue("Provider put must call checkPermission "
458                + "SecurityPermission putProviderProperty.Name", sm.called);
459        System.setSecurityManager(null);
460    }
461    // END android-added
462
463    // BEGIN android-added
464    @TestTargetNew(
465        level = TestLevel.PARTIAL_COMPLETE,
466        notes = "",
467        method = "remove",
468        args = {java.lang.Object.class}
469    )
470    public final void testRemoveObject_SecurityManager() {
471        TestSecurityManager sm = new TestSecurityManager(
472                "removeProviderProperty.MyProvider");
473        System.setSecurityManager(sm);
474        p.remove(new Object());
475        assertTrue("Provider.remove must check permission "
476                + "SecurityPermission removeProviderProperty.NAME",
477                sm.called);
478        System.setSecurityManager(null);
479    }
480    // END android-added
481
482    // BEGIN android-added
483    @TestTargetNew(
484            level = TestLevel.COMPLETE,
485            notes = "",
486            method = "getService",
487            args = {java.lang.String.class, java.lang.String.class}
488        )
489    public final void testService2() {
490        Provider[] pp = Security.getProviders("MessageDigest.ASH-1");
491        if (pp == null) {
492            return;
493        }
494        Provider p2 = pp[0];
495        String old = p2.getProperty("MessageDigest.ASH-1");
496        p2.put("MessageDigest.ASH-1", "AnotherClassName");
497        Provider.Service s = p2.getService("MessageDigest", "ASH-1");
498        if (!"AnotherClassName".equals(s.getClassName())) {
499            fail("Incorrect class name " + s.getClassName());
500        }
501        try {
502            s.newInstance(null);
503            fail("No expected NoSuchAlgorithmException");
504        } catch (NoSuchAlgorithmException e) {
505        }
506    }
507    // END android-added
508
509    // BEGIN android-added
510    @TestTargetNew(
511        level = TestLevel.COMPLETE,
512        notes = "",
513        method = "getServices",
514        args = {}
515    )
516    public final void testGetServices() {
517        MyProvider myProvider = new MyProvider(null, 1, null);
518        Set<Provider.Service> services = myProvider.getServices();
519        assertEquals(0, services.size());
520
521        Provider.Service s[] = new Provider.Service[3];
522
523        s[0] = new Provider.Service(p, "type1", "algorithm1", "className1",
524                null, null);
525        s[1] = new Provider.Service(p, "type2", "algorithm2", "className2",
526                null, null);
527        s[2] = new Provider.Service(p, "type3", "algorithm3", "className3",
528                null, null);
529        myProvider.putService(s[0]);
530        myProvider.putService(s[1]);
531        assertEquals(2, myProvider.getNumServices());
532        Set<Service> actual = myProvider.getServices();
533
534        assertTrue(actual.contains(s[0]));
535        assertTrue(actual.contains(s[1]));
536        assertTrue(!actual.contains(s[2]));
537
538        myProvider.removeService(s[1]);
539        actual = myProvider.getServices();
540        assertEquals(1, myProvider.getNumServices());
541
542        assertTrue(actual.contains(s[0]));
543        assertTrue(!actual.contains(s[1]));
544        assertTrue(!actual.contains(s[2]));
545
546        myProvider.putService(s[2]);
547        actual = myProvider.getServices();
548        assertEquals(2, myProvider.getNumServices());
549        assertTrue(actual.contains(s[0]));
550        assertTrue(!actual.contains(s[1]));
551        assertTrue(actual.contains(s[2]));
552    }
553    // END android-added
554
555    // BEGIN android-added
556    @TestTargetNew(
557        level = TestLevel.COMPLETE,
558        notes = "",
559        method = "putService",
560        args = {java.security.Provider.Service.class}
561    )
562    public final void testPutService() {
563        MyProvider myProvider = new MyProvider(null, 1, null);
564        Provider.Service s[] = new Provider.Service[3];
565
566        s[0] = new Provider.Service(p, "type1", "algorithm1", "className1",
567                null, null);
568        s[1] = new Provider.Service(p, "type2", "algorithm2", "className2",
569                null, null);
570        s[2] = new Provider.Service(p, "type3", "algorithm3", "className3",
571                null, null);
572        myProvider.putService(s[0]);
573        myProvider.putService(s[1]);
574        assertEquals(2, myProvider.getNumServices());
575        Set<Service> actual = myProvider.getServices();
576
577        assertTrue(actual.contains(s[0]));
578        assertTrue(actual.contains(s[1]));
579        assertTrue(!actual.contains(s[2]));
580
581        myProvider.removeService(s[1]);
582        assertEquals(1, myProvider.getNumServices());
583        actual = myProvider.getServices();
584
585        assertTrue(actual.contains(s[0]));
586        assertTrue(!actual.contains(s[1]));
587        assertTrue(!actual.contains(s[2]));
588
589        myProvider.putService(s[2]);
590        actual = myProvider.getServices();
591        assertEquals(2, myProvider.getNumServices());
592        assertTrue(actual.contains(s[0]));
593        assertTrue(!actual.contains(s[1]));
594        assertTrue(actual.contains(s[2]));
595
596        myProvider.putService(s[2]);
597        actual = myProvider.getServices();
598        assertEquals(2, myProvider.getNumServices());
599        assertTrue(actual.contains(s[0]));
600        assertTrue(!actual.contains(s[1]));
601        assertTrue(actual.contains(s[2]));
602
603        try {
604            myProvider.putService(null);
605            fail("NullPointerException expected");
606        } catch (NullPointerException e) {
607            // expected
608        }
609    }
610    // END android-added
611
612    // BEGIN android-added
613    @TestTargetNew(
614        level = TestLevel.COMPLETE,
615        notes = "",
616        method = "removeService",
617        args = {java.security.Provider.Service.class}
618    )
619    public final void testRemoveService() {
620        MyProvider myProvider = new MyProvider(null, 1, null);
621        try {
622            myProvider.removeService(null);
623            fail("NullPoiterException expected");
624        } catch (NullPointerException e) {
625            // expected
626        }
627
628        Provider.Service s[] = new Provider.Service[3];
629
630        s[0] = new Provider.Service(p, "type0", "algorithm0", "className0",
631                null, null);
632        s[1] = new Provider.Service(p, "type1", "algorithm1", "className1",
633                null, null);
634        s[2] = new Provider.Service(p, "type2", "algorithm2", "className2",
635                null, null);
636
637        try {
638            myProvider.removeService(s[0]);
639        } catch (NullPointerException e) {
640            fail("Unexpected exception");
641        }
642
643        myProvider.putService(s[0]);
644        myProvider.putService(s[1]);
645        myProvider.putService(s[2]);
646        assertEquals(3, myProvider.getNumServices());
647        Set<Service> actual = myProvider.getServices();
648
649        assertTrue(actual.contains(s[0]));
650        assertTrue(actual.contains(s[1]));
651        assertTrue(actual.contains(s[2]));
652
653        myProvider.removeService(s[1]);
654        assertEquals(2, myProvider.getNumServices());
655        actual = myProvider.getServices();
656
657        assertTrue(actual.contains(s[0]));
658        assertTrue(!actual.contains(s[1]));
659        assertTrue(actual.contains(s[2]));
660
661        myProvider.removeService(s[0]);
662        assertEquals(1, myProvider.getNumServices());
663        actual = myProvider.getServices();
664
665        assertTrue(!actual.contains(s[0]));
666        assertTrue(!actual.contains(s[1]));
667        assertTrue(actual.contains(s[2]));
668
669        myProvider.removeService(s[2]);
670        assertEquals(0, myProvider.getNumServices());
671        actual = myProvider.getServices();
672
673        assertTrue(!actual.contains(s[0]));
674        assertTrue(!actual.contains(s[1]));
675        assertTrue(!actual.contains(s[2]));
676
677        try {
678            myProvider.removeService(null);
679            fail("NullPoiterException expected");
680        } catch (NullPointerException e) {
681            // expected
682        }
683    }
684    // END android-added
685
686    // BEGIN android-added
687    @TestTargetNew(
688        level = TestLevel.PARTIAL_COMPLETE,
689        notes = "",
690        method = "load",
691        args = {java.io.InputStream.class}
692    )
693    public final void testLoad() throws IOException {
694        InputStream is = new ByteArrayInputStream(writeProperties());
695        MyProvider myProvider = new MyProvider("name", 1, "info");
696        myProvider.load(is);
697        assertEquals("tests.security", myProvider.get("test.pkg"));
698        assertEquals("Unit Tests", myProvider.get("test.proj"));
699        assertNull(myProvider.get("#commented.entry"));
700
701        assertEquals("info", myProvider.get("Provider.id info"));
702        String className = myProvider.getClass().toString();
703        assertEquals(
704                className.substring("class ".length(), className.length()),
705                myProvider.get("Provider.id className"));
706        assertEquals("1.0", myProvider.get("Provider.id version"));
707
708        try {
709            myProvider.load((InputStream) null);
710            fail("NullPointerException expected");
711        } catch (NullPointerException e) {
712            // expected
713        }
714    }
715    // END android-added
716
717    // BEGIN android-added
718    @TestTargetNew(
719            level = TestLevel.PARTIAL_COMPLETE,
720            notes = "",
721            method = "load",
722            args = {java.io.InputStream.class}
723        )
724    public final void testLoad2() {
725        class TestInputStream extends InputStream {
726            @Override
727            public int read() throws IOException {
728                throw new IOException();
729            }
730        }
731
732        MyProvider p = new MyProvider();
733        try {
734            p.load(new TestInputStream());
735            fail("expected IOException");
736        } catch (IOException e) {
737            // expected
738        }
739    }
740    // END android-added
741
742    // BEGIN android-added
743    protected byte[] writeProperties() {
744        ByteArrayOutputStream bout = new ByteArrayOutputStream();
745        PrintStream ps = new PrintStream(bout);
746        ps.println("#commented.entry=Bogus");
747        ps.println("test.pkg=tests.security");
748        ps.println("test.proj=Unit Tests");
749        ps.close();
750        return bout.toByteArray();
751    }
752    // END android-added
753
754    // BEGIN android-added
755    static class TestSecurityManager extends SecurityManager {
756        boolean called = false;
757        private final String permissionName;
758
759        public TestSecurityManager(String permissionName) {
760            this.permissionName = permissionName;
761        }
762
763        @Override
764        public void checkPermission(Permission permission) {
765            if (permission instanceof SecurityPermission) {
766                if (permissionName.equals(permission.getName())) {
767                    called = true;
768                }
769            }
770        }
771    }
772    // END android-added
773}
774