修订版 | e831bf41aaf28d5abe8ced4218d36b84faa765d5 (tree) |
---|---|
时间 | 2011-06-26 15:35:28 |
作者 | Chih-Wei Huang <cwhuang@linu...> |
Commiter | Chih-Wei Huang |
Merge remote-tracking branch 'korg/froyo' into froyo-x86
@@ -1,1317 +1,1184 @@ | ||
1 | 1 | /* |
2 | - * Written by Doug Lea with assistance from members of JCP JSR-166 | |
3 | - * Expert Group. Adapted and released, under explicit permission, | |
4 | - * from JDK ArrayList.java which carries the following copyright: | |
5 | - * | |
6 | - * Copyright 1997 by Sun Microsystems, Inc., | |
7 | - * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A. | |
8 | - * All rights reserved. | |
9 | - * | |
10 | - * This software is the confidential and proprietary information | |
11 | - * of Sun Microsystems, Inc. ("Confidential Information"). You | |
12 | - * shall not disclose such Confidential Information and shall use | |
13 | - * it only in accordance with the terms of the license agreement | |
14 | - * you entered into with Sun. | |
2 | + * Licensed to the Apache Software Foundation (ASF) under one or more | |
3 | + * contributor license agreements. See the NOTICE file distributed with this | |
4 | + * work for additional information regarding copyright ownership. The ASF | |
5 | + * licenses this file to you under the Apache License, Version 2.0 (the | |
6 | + * "License"); you may not use this file except in compliance with the License. | |
7 | + * 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, WITHOUT | |
13 | + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the | |
14 | + * License for the specific language governing permissions and limitations under | |
15 | + * the License. | |
15 | 16 | */ |
16 | 17 | |
17 | 18 | package java.util.concurrent; |
18 | -import java.util.*; | |
19 | -import java.util.concurrent.locks.*; | |
20 | -import java.lang.reflect.Array; | |
21 | - | |
22 | -import sun.misc.Unsafe; | |
23 | 19 | |
24 | -// BEGIN android-note | |
25 | -// removed link to collections framework docs | |
26 | -// END android-note | |
20 | +import java.io.IOException; | |
21 | +import java.io.ObjectInputStream; | |
22 | +import java.io.ObjectOutputStream; | |
23 | +import java.io.Serializable; | |
24 | +import java.lang.reflect.Array; | |
25 | +import java.util.Collection; | |
26 | +import java.util.ConcurrentModificationException; | |
27 | +import java.util.Iterator; | |
28 | +import java.util.List; | |
29 | +import java.util.ListIterator; | |
30 | +import java.util.NoSuchElementException; | |
31 | +import java.util.RandomAccess; | |
32 | +import java.util.concurrent.locks.ReentrantLock; | |
27 | 33 | |
28 | 34 | /** |
29 | - * A thread-safe variant of {@link java.util.ArrayList} in which all mutative | |
30 | - * operations (<tt>add</tt>, <tt>set</tt>, and so on) are implemented by | |
31 | - * making a fresh copy of the underlying array. | |
32 | - * | |
33 | - * <p> This is ordinarily too costly, but may be <em>more</em> efficient | |
34 | - * than alternatives when traversal operations vastly outnumber | |
35 | - * mutations, and is useful when you cannot or don't want to | |
36 | - * synchronize traversals, yet need to preclude interference among | |
37 | - * concurrent threads. The "snapshot" style iterator method uses a | |
38 | - * reference to the state of the array at the point that the iterator | |
39 | - * was created. This array never changes during the lifetime of the | |
40 | - * iterator, so interference is impossible and the iterator is | |
41 | - * guaranteed not to throw <tt>ConcurrentModificationException</tt>. | |
42 | - * The iterator will not reflect additions, removals, or changes to | |
43 | - * the list since the iterator was created. Element-changing | |
44 | - * operations on iterators themselves (<tt>remove</tt>, <tt>set</tt>, and | |
45 | - * <tt>add</tt>) are not supported. These methods throw | |
46 | - * <tt>UnsupportedOperationException</tt>. | |
47 | - * | |
48 | - * <p>All elements are permitted, including <tt>null</tt>. | |
49 | - * | |
50 | - * <p>Memory consistency effects: As with other concurrent | |
51 | - * collections, actions in a thread prior to placing an object into a | |
52 | - * {@code CopyOnWriteArrayList} | |
53 | - * <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a> | |
54 | - * actions subsequent to the access or removal of that element from | |
55 | - * the {@code CopyOnWriteArrayList} in another thread. | |
35 | + * Implements a {@link java.util.ArrayList} variant that is thread-safe. All | |
36 | + * write operation result in a new copy of the underlying data being created. | |
37 | + * Iterators reflect the state of the CopyOnWriteArrayList at the time they were | |
38 | + * created. They are not updated to reflect subsequent changes to the list. In | |
39 | + * addition, these iterators cannot be used for modifying the underlying | |
40 | + * CopyOnWriteArrayList. | |
56 | 41 | * |
57 | - * @since 1.5 | |
58 | - * @author Doug Lea | |
59 | - * @param <E> the type of elements held in this collection | |
42 | + * @param <E> the element type | |
60 | 43 | */ |
61 | -public class CopyOnWriteArrayList<E> | |
62 | - implements List<E>, RandomAccess, Cloneable, java.io.Serializable { | |
63 | - private static final long serialVersionUID = 8673264195747942595L; | |
64 | - | |
65 | - /** The lock protecting all mutators */ | |
66 | - transient final ReentrantLock lock = new ReentrantLock(); | |
44 | +public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, Serializable { | |
67 | 45 | |
68 | - /** The array, accessed only via getArray/setArray. */ | |
69 | - private volatile transient Object[] array; | |
46 | + private static final long serialVersionUID = 8673264195747942595L; | |
70 | 47 | |
71 | - /** | |
72 | - * Gets the array. Non-private so as to also be accessible | |
73 | - * from CopyOnWriteArraySet class. | |
74 | - */ | |
75 | - final Object[] getArray() { | |
76 | - return array; | |
77 | - } | |
48 | + private transient volatile E[] arr; | |
78 | 49 | |
79 | 50 | /** |
80 | - * Sets the array. | |
51 | + * Lock for the queue write methods | |
81 | 52 | */ |
82 | - final void setArray(Object[] a) { | |
83 | - array = a; | |
84 | - } | |
53 | + private final transient ReentrantLock lock = new ReentrantLock(); | |
85 | 54 | |
86 | 55 | /** |
87 | - * Creates an empty list. | |
56 | + * Creates a new, empty instance of CopyOnWriteArrayList. | |
88 | 57 | */ |
89 | 58 | public CopyOnWriteArrayList() { |
90 | - setArray(new Object[0]); | |
91 | 59 | } |
92 | 60 | |
93 | 61 | /** |
94 | - * Creates a list containing the elements of the specified | |
95 | - * collection, in the order they are returned by the collection's | |
96 | - * iterator. | |
62 | + * Creates a new instance of CopyOnWriteArrayList and fills it with the | |
63 | + * contents of a given Collection. | |
97 | 64 | * |
98 | - * @param c the collection of initially held elements | |
99 | - * @throws NullPointerException if the specified collection is null | |
65 | + * @param c the collection the elements of which are to be copied into | |
66 | + * the new instance. | |
100 | 67 | */ |
101 | 68 | public CopyOnWriteArrayList(Collection<? extends E> c) { |
102 | - Object[] elements = c.toArray(); | |
103 | - // c.toArray might (incorrectly) not return Object[] (see 6260652) | |
104 | - if (elements.getClass() != Object[].class) | |
105 | - elements = Java6Arrays.copyOf(elements, elements.length, Object[].class); | |
106 | - setArray(elements); | |
69 | + this((E[]) c.toArray()); | |
107 | 70 | } |
108 | 71 | |
109 | 72 | /** |
110 | - * Creates a list holding a copy of the given array. | |
73 | + * Creates a new instance of CopyOnWriteArrayList and fills it with the | |
74 | + * contents of a given array. | |
111 | 75 | * |
112 | - * @param toCopyIn the array (a copy of this array is used as the | |
113 | - * internal array) | |
114 | - * @throws NullPointerException if the specified array is null | |
76 | + * @param array the array the elements of which are to be copied into the | |
77 | + * new instance. | |
115 | 78 | */ |
116 | - public CopyOnWriteArrayList(E[] toCopyIn) { | |
117 | - setArray(Java6Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class)); | |
79 | + public CopyOnWriteArrayList(E[] array) { | |
80 | + int size = array.length; | |
81 | + E[] data = newElementArray(size); | |
82 | + for (int i = 0; i < size; i++) { | |
83 | + data[i] = array[i]; | |
84 | + } | |
85 | + arr = data; | |
118 | 86 | } |
119 | 87 | |
120 | - /** | |
121 | - * Returns the number of elements in this list. | |
122 | - * | |
123 | - * @return the number of elements in this list | |
124 | - */ | |
125 | - public int size() { | |
126 | - return getArray().length; | |
88 | + public boolean add(E e) { | |
89 | + lock.lock(); | |
90 | + try { | |
91 | + E[] data; | |
92 | + E[] old = getData(); | |
93 | + int size = old.length; | |
94 | + data = newElementArray(size + 1); | |
95 | + System.arraycopy(old, 0, data, 0, size); | |
96 | + data[size] = e; | |
97 | + setData(data); | |
98 | + return true; | |
99 | + } finally { | |
100 | + lock.unlock(); | |
101 | + } | |
127 | 102 | } |
128 | 103 | |
129 | - /** | |
130 | - * Returns <tt>true</tt> if this list contains no elements. | |
131 | - * | |
132 | - * @return <tt>true</tt> if this list contains no elements | |
133 | - */ | |
134 | - public boolean isEmpty() { | |
135 | - return size() == 0; | |
104 | + public void add(int index, E e) { | |
105 | + lock.lock(); | |
106 | + try { | |
107 | + E[] data; | |
108 | + E[] old = getData(); | |
109 | + int size = old.length; | |
110 | + checkIndexInclusive(index, size); | |
111 | + data = newElementArray(size+1); | |
112 | + System.arraycopy(old, 0, data, 0, index); | |
113 | + data[index] = e; | |
114 | + if (size > index) { | |
115 | + System.arraycopy(old, index, data, index + 1, size - index); | |
116 | + } | |
117 | + setData(data); | |
118 | + } finally { | |
119 | + lock.unlock(); | |
120 | + } | |
136 | 121 | } |
137 | 122 | |
138 | - /** | |
139 | - * Test for equality, coping with nulls. | |
140 | - */ | |
141 | - private static boolean eq(Object o1, Object o2) { | |
142 | - return (o1 == null ? o2 == null : o1.equals(o2)); | |
123 | + public boolean addAll(Collection<? extends E> c) { | |
124 | + Iterator it = c.iterator(); | |
125 | + int ssize = c.size(); | |
126 | + lock.lock(); | |
127 | + try { | |
128 | + int size = size(); | |
129 | + E[] data; | |
130 | + E[] old = getData(); | |
131 | + int nSize = size + ssize; | |
132 | + data = newElementArray(nSize); | |
133 | + System.arraycopy(old, 0, data, 0, size); | |
134 | + while (it.hasNext()) { | |
135 | + data[size++] = (E) it.next(); | |
136 | + } | |
137 | + setData(data); | |
138 | + } finally { | |
139 | + lock.unlock(); | |
140 | + } | |
141 | + return true; | |
143 | 142 | } |
144 | 143 | |
145 | - /** | |
146 | - * static version of indexOf, to allow repeated calls without | |
147 | - * needing to re-acquire array each time. | |
148 | - * @param o element to search for | |
149 | - * @param elements the array | |
150 | - * @param index first index to search | |
151 | - * @param fence one past last index to search | |
152 | - * @return index of element, or -1 if absent | |
153 | - */ | |
154 | - private static int indexOf(Object o, Object[] elements, | |
155 | - int index, int fence) { | |
156 | - if (o == null) { | |
157 | - for (int i = index; i < fence; i++) | |
158 | - if (elements[i] == null) | |
159 | - return i; | |
160 | - } else { | |
161 | - for (int i = index; i < fence; i++) | |
162 | - if (o.equals(elements[i])) | |
163 | - return i; | |
144 | + public boolean addAll(int index, Collection<? extends E> c) { | |
145 | + Iterator it = c.iterator(); | |
146 | + int ssize = c.size(); | |
147 | + lock.lock(); | |
148 | + try { | |
149 | + int size = size(); | |
150 | + checkIndexInclusive(index, size); | |
151 | + E[] data; | |
152 | + E[] old = getData(); | |
153 | + int nSize = size + ssize; | |
154 | + data = newElementArray(nSize); | |
155 | + System.arraycopy(old, 0, data, 0, index); | |
156 | + int i = index; | |
157 | + while (it.hasNext()) { | |
158 | + data[i++] = (E) it.next(); | |
159 | + } | |
160 | + if (size > index) { | |
161 | + System.arraycopy(old, index, data, index + ssize, size - index); | |
162 | + } | |
163 | + setData(data); | |
164 | + } finally { | |
165 | + lock.unlock(); | |
164 | 166 | } |
165 | - return -1; | |
167 | + return true; | |
166 | 168 | } |
167 | 169 | |
168 | 170 | /** |
169 | - * static version of lastIndexOf. | |
170 | - * @param o element to search for | |
171 | - * @param elements the array | |
172 | - * @param index first index to search | |
173 | - * @return index of element, or -1 if absent | |
171 | + * Adds to this CopyOnWriteArrayList all those elements from a given | |
172 | + * collection that are not yet part of the list. | |
173 | + * | |
174 | + * @param c the collection from which the potential new elements are | |
175 | + * taken. | |
176 | + * | |
177 | + * @return the number of elements actually added to this list. | |
174 | 178 | */ |
175 | - private static int lastIndexOf(Object o, Object[] elements, int index) { | |
176 | - if (o == null) { | |
177 | - for (int i = index; i >= 0; i--) | |
178 | - if (elements[i] == null) | |
179 | - return i; | |
180 | - } else { | |
181 | - for (int i = index; i >= 0; i--) | |
182 | - if (o.equals(elements[i])) | |
183 | - return i; | |
179 | + public int addAllAbsent(Collection<? extends E> c) { | |
180 | + if (c.size() == 0) { | |
181 | + return 0; | |
182 | + } | |
183 | + lock.lock(); | |
184 | + try { | |
185 | + E[] old = getData(); | |
186 | + int size = old.length; | |
187 | + E[] toAdd = newElementArray(c.size()); | |
188 | + int i = 0; | |
189 | + for (Iterator it = c.iterator(); it.hasNext();) { | |
190 | + E o = (E) it.next(); | |
191 | + if (indexOf(o) < 0) { | |
192 | + toAdd[i++] = o; | |
193 | + } | |
194 | + } | |
195 | + E[] data = newElementArray(size + i); | |
196 | + System.arraycopy(old, 0, data, 0, size); | |
197 | + System.arraycopy(toAdd, 0, data, size, i); | |
198 | + setData(data); | |
199 | + return i; | |
200 | + } finally { | |
201 | + lock.unlock(); | |
184 | 202 | } |
185 | - return -1; | |
186 | 203 | } |
187 | 204 | |
188 | 205 | /** |
189 | - * Returns <tt>true</tt> if this list contains the specified element. | |
190 | - * More formally, returns <tt>true</tt> if and only if this list contains | |
191 | - * at least one element <tt>e</tt> such that | |
192 | - * <tt>(o==null ? e==null : o.equals(e))</tt>. | |
206 | + * Adds to this CopyOnWriteArrayList another element, given that this | |
207 | + * element is not yet part of the list. | |
208 | + * | |
209 | + * @param e the potential new element. | |
193 | 210 | * |
194 | - * @param o element whose presence in this list is to be tested | |
195 | - * @return <tt>true</tt> if this list contains the specified element | |
211 | + * @return true if the element was added, or false otherwise. | |
196 | 212 | */ |
197 | - public boolean contains(Object o) { | |
198 | - Object[] elements = getArray(); | |
199 | - return indexOf(o, elements, 0, elements.length) >= 0; | |
213 | + public boolean addIfAbsent(E e) { | |
214 | + lock.lock(); | |
215 | + try { | |
216 | + E[] data; | |
217 | + E[] old = getData(); | |
218 | + int size = old.length; | |
219 | + if (size != 0) { | |
220 | + if (indexOf(e) >= 0) { | |
221 | + return false; | |
222 | + } | |
223 | + } | |
224 | + data = newElementArray(size + 1); | |
225 | + System.arraycopy(old, 0, data, 0, size); | |
226 | + data[size] = e; | |
227 | + setData(data); | |
228 | + return true; | |
229 | + } finally { | |
230 | + lock.unlock(); | |
231 | + } | |
200 | 232 | } |
201 | 233 | |
202 | - /** | |
203 | - * {@inheritDoc} | |
204 | - */ | |
205 | - public int indexOf(Object o) { | |
206 | - Object[] elements = getArray(); | |
207 | - return indexOf(o, elements, 0, elements.length); | |
234 | + public void clear() { | |
235 | + lock.lock(); | |
236 | + try { | |
237 | + setData(newElementArray(0)); | |
238 | + } finally { | |
239 | + lock.unlock(); | |
240 | + } | |
208 | 241 | } |
209 | 242 | |
210 | - /** | |
211 | - * Returns the index of the first occurrence of the specified element in | |
212 | - * this list, searching forwards from <tt>index</tt>, or returns -1 if | |
213 | - * the element is not found. | |
214 | - * More formally, returns the lowest index <tt>i</tt> such that | |
215 | - * <tt>(i >= index && (e==null ? get(i)==null : e.equals(get(i))))</tt>, | |
216 | - * or -1 if there is no such index. | |
217 | - * | |
218 | - * @param e element to search for | |
219 | - * @param index index to start searching from | |
220 | - * @return the index of the first occurrence of the element in | |
221 | - * this list at position <tt>index</tt> or later in the list; | |
222 | - * <tt>-1</tt> if the element is not found. | |
223 | - * @throws IndexOutOfBoundsException if the specified index is negative | |
224 | - */ | |
225 | - public int indexOf(E e, int index) { | |
226 | - Object[] elements = getArray(); | |
227 | - return indexOf(e, elements, index, elements.length); | |
243 | + @Override | |
244 | + public Object clone() { | |
245 | + try { | |
246 | + CopyOnWriteArrayList thisClone = (CopyOnWriteArrayList) super.clone(); | |
247 | + thisClone.setData(this.getData()); | |
248 | + return thisClone; | |
249 | + } catch (CloneNotSupportedException e) { | |
250 | + throw new RuntimeException("CloneNotSupportedException is not expected here"); | |
251 | + } | |
228 | 252 | } |
229 | 253 | |
230 | - /** | |
231 | - * {@inheritDoc} | |
232 | - */ | |
233 | - public int lastIndexOf(Object o) { | |
234 | - Object[] elements = getArray(); | |
235 | - return lastIndexOf(o, elements, elements.length - 1); | |
254 | + public boolean contains(Object o) { | |
255 | + return indexOf(o) >= 0; | |
236 | 256 | } |
237 | 257 | |
238 | - /** | |
239 | - * Returns the index of the last occurrence of the specified element in | |
240 | - * this list, searching backwards from <tt>index</tt>, or returns -1 if | |
241 | - * the element is not found. | |
242 | - * More formally, returns the highest index <tt>i</tt> such that | |
243 | - * <tt>(i <= index && (e==null ? get(i)==null : e.equals(get(i))))</tt>, | |
244 | - * or -1 if there is no such index. | |
245 | - * | |
246 | - * @param e element to search for | |
247 | - * @param index index to start searching backwards from | |
248 | - * @return the index of the last occurrence of the element at position | |
249 | - * less than or equal to <tt>index</tt> in this list; | |
250 | - * -1 if the element is not found. | |
251 | - * @throws IndexOutOfBoundsException if the specified index is greater | |
252 | - * than or equal to the current size of this list | |
253 | - */ | |
254 | - public int lastIndexOf(E e, int index) { | |
255 | - Object[] elements = getArray(); | |
256 | - return lastIndexOf(e, elements, index); | |
258 | + public boolean containsAll(Collection<?> c) { | |
259 | + E[] data = getData(); | |
260 | + return containsAll(c, data, 0, data.length); | |
257 | 261 | } |
258 | 262 | |
259 | - /** | |
260 | - * Returns a shallow copy of this list. (The elements themselves | |
261 | - * are not copied.) | |
262 | - * | |
263 | - * @return a clone of this list | |
264 | - */ | |
265 | - public Object clone() { | |
266 | - try { | |
267 | - CopyOnWriteArrayList c = (CopyOnWriteArrayList)(super.clone()); | |
268 | - c.resetLock(); | |
269 | - return c; | |
270 | - } catch (CloneNotSupportedException e) { | |
271 | - // this shouldn't happen, since we are Cloneable | |
272 | - throw new InternalError(); | |
263 | + public boolean equals(Object o) { | |
264 | + if (o == this) { | |
265 | + return true; | |
266 | + } | |
267 | + if (!(o instanceof List)) { | |
268 | + return false; | |
269 | + } | |
270 | + List l = (List) o; | |
271 | + Iterator it = l.listIterator(); | |
272 | + Iterator ourIt = listIterator(); | |
273 | + while (it.hasNext()) { | |
274 | + if (!ourIt.hasNext()) { | |
275 | + return false; | |
276 | + } | |
277 | + Object thisListElem = it.next(); | |
278 | + Object anotherListElem = ourIt.next(); | |
279 | + if (!(thisListElem == null ? anotherListElem == null : thisListElem | |
280 | + .equals(anotherListElem))) { | |
281 | + return false; | |
282 | + } | |
273 | 283 | } |
284 | + if (ourIt.hasNext()) { | |
285 | + return false; | |
286 | + } | |
287 | + return true; | |
288 | + } | |
289 | + | |
290 | + public E get(int index) { | |
291 | + E[] data = getData(); | |
292 | + return data[index]; | |
293 | + } | |
294 | + | |
295 | + public int hashCode() { | |
296 | + int hashCode = 1; | |
297 | + Iterator it = listIterator(); | |
298 | + while (it.hasNext()) { | |
299 | + Object obj = it.next(); | |
300 | + hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode()); | |
301 | + } | |
302 | + return hashCode; | |
274 | 303 | } |
275 | 304 | |
276 | 305 | /** |
277 | - * Returns an array containing all of the elements in this list | |
278 | - * in proper sequence (from first to last element). | |
306 | + * Returns the index of a given element, starting the search from a given | |
307 | + * position in the list. | |
279 | 308 | * |
280 | - * <p>The returned array will be "safe" in that no references to it are | |
281 | - * maintained by this list. (In other words, this method must allocate | |
282 | - * a new array). The caller is thus free to modify the returned array. | |
309 | + * @param e the element to search. | |
310 | + * @param index the index at which to start the search. | |
283 | 311 | * |
284 | - * <p>This method acts as bridge between array-based and collection-based | |
285 | - * APIs. | |
286 | - * | |
287 | - * @return an array containing all the elements in this list | |
312 | + * @return the index of the element or null, if the element has not been | |
313 | + * found at or beyond the given start index. | |
288 | 314 | */ |
289 | - public Object[] toArray() { | |
290 | - Object[] elements = getArray(); | |
291 | - return Java6Arrays.copyOf(elements, elements.length); | |
315 | + public int indexOf(E e, int index) { | |
316 | + E[] data = getData(); | |
317 | + return indexOf(e, data, index, data.length - index); | |
318 | + } | |
319 | + | |
320 | + public int indexOf(Object o) { | |
321 | + E[] data = getData(); | |
322 | + return indexOf(o, data, 0, data.length); | |
323 | + } | |
324 | + | |
325 | + public boolean isEmpty() { | |
326 | + return size() == 0; | |
327 | + } | |
328 | + | |
329 | + public Iterator<E> iterator() { | |
330 | + return new ListIteratorImpl(getData(), 0); | |
292 | 331 | } |
293 | 332 | |
294 | 333 | /** |
295 | - * Returns an array containing all of the elements in this list in | |
296 | - * proper sequence (from first to last element); the runtime type of | |
297 | - * the returned array is that of the specified array. If the list fits | |
298 | - * in the specified array, it is returned therein. Otherwise, a new | |
299 | - * array is allocated with the runtime type of the specified array and | |
300 | - * the size of this list. | |
301 | - * | |
302 | - * <p>If this list fits in the specified array with room to spare | |
303 | - * (i.e., the array has more elements than this list), the element in | |
304 | - * the array immediately following the end of the list is set to | |
305 | - * <tt>null</tt>. (This is useful in determining the length of this | |
306 | - * list <i>only</i> if the caller knows that this list does not contain | |
307 | - * any null elements.) | |
308 | - * | |
309 | - * <p>Like the {@link #toArray()} method, this method acts as bridge between | |
310 | - * array-based and collection-based APIs. Further, this method allows | |
311 | - * precise control over the runtime type of the output array, and may, | |
312 | - * under certain circumstances, be used to save allocation costs. | |
334 | + * Returns the last index of a given element, starting the search from | |
335 | + * a given position in the list and going backwards. | |
313 | 336 | * |
314 | - * <p>Suppose <tt>x</tt> is a list known to contain only strings. | |
315 | - * The following code can be used to dump the list into a newly | |
316 | - * allocated array of <tt>String</tt>: | |
337 | + * @param e the element to search. | |
338 | + * @param index the index at which to start the search. | |
317 | 339 | * |
318 | - * <pre> | |
319 | - * String[] y = x.toArray(new String[0]);</pre> | |
320 | - * | |
321 | - * Note that <tt>toArray(new Object[0])</tt> is identical in function to | |
322 | - * <tt>toArray()</tt>. | |
323 | - * | |
324 | - * @param a the array into which the elements of the list are to | |
325 | - * be stored, if it is big enough; otherwise, a new array of the | |
326 | - * same runtime type is allocated for this purpose. | |
327 | - * @return an array containing all the elements in this list | |
328 | - * @throws ArrayStoreException if the runtime type of the specified array | |
329 | - * is not a supertype of the runtime type of every element in | |
330 | - * this list | |
331 | - * @throws NullPointerException if the specified array is null | |
340 | + * @return the index of the element or null, if the element has not been | |
341 | + * found at or before the given start index. | |
332 | 342 | */ |
333 | - @SuppressWarnings("unchecked") | |
334 | - public <T> T[] toArray(T a[]) { | |
335 | - Object[] elements = getArray(); | |
336 | - int len = elements.length; | |
337 | - if (a.length < len) | |
338 | - return (T[]) Java6Arrays.copyOf(elements, len, a.getClass()); | |
339 | - else { | |
340 | - System.arraycopy(elements, 0, a, 0, len); | |
341 | - if (a.length > len) | |
342 | - a[len] = null; | |
343 | - return a; | |
344 | - } | |
343 | + public int lastIndexOf(E e, int index) { | |
344 | + E[] data = getData(); | |
345 | + return lastIndexOf(e, data, 0, index); | |
345 | 346 | } |
346 | 347 | |
347 | - // Positional Access Operations | |
348 | + public int lastIndexOf(Object o) { | |
349 | + E[] data = getData(); | |
350 | + return lastIndexOf(o, data, 0, data.length); | |
351 | + } | |
348 | 352 | |
349 | - @SuppressWarnings("unchecked") | |
350 | - private E get(Object[] a, int index) { | |
351 | - return (E) a[index]; | |
353 | + public ListIterator<E> listIterator() { | |
354 | + return new ListIteratorImpl(getData(), 0); | |
352 | 355 | } |
353 | 356 | |
354 | - /** | |
355 | - * {@inheritDoc} | |
356 | - * | |
357 | - * @throws IndexOutOfBoundsException {@inheritDoc} | |
358 | - */ | |
359 | - public E get(int index) { | |
360 | - return get(getArray(), index); | |
357 | + public ListIterator<E> listIterator(int index) { | |
358 | + E[] data = getData(); | |
359 | + checkIndexInclusive(index, data.length); | |
360 | + return new ListIteratorImpl(data, index); | |
361 | 361 | } |
362 | 362 | |
363 | - /** | |
364 | - * Replaces the element at the specified position in this list with the | |
365 | - * specified element. | |
366 | - * | |
367 | - * @throws IndexOutOfBoundsException {@inheritDoc} | |
368 | - */ | |
369 | - public E set(int index, E element) { | |
370 | - final ReentrantLock lock = this.lock; | |
363 | + public E remove(int index) { | |
364 | + return removeRange(index, 1); | |
365 | + } | |
366 | + | |
367 | + public boolean remove(Object o) { | |
371 | 368 | lock.lock(); |
372 | 369 | try { |
373 | - Object[] elements = getArray(); | |
374 | - E oldValue = get(elements, index); | |
375 | - | |
376 | - if (oldValue != element) { | |
377 | - int len = elements.length; | |
378 | - Object[] newElements = Java6Arrays.copyOf(elements, len); | |
379 | - newElements[index] = element; | |
380 | - setArray(newElements); | |
381 | - } else { | |
382 | - // Not quite a no-op; ensures volatile write semantics | |
383 | - setArray(elements); | |
370 | + int index = indexOf(o); | |
371 | + if (index == -1) { | |
372 | + return false; | |
384 | 373 | } |
385 | - return oldValue; | |
374 | + remove(index); | |
375 | + return true; | |
386 | 376 | } finally { |
387 | 377 | lock.unlock(); |
388 | 378 | } |
389 | 379 | } |
390 | 380 | |
391 | - /** | |
392 | - * Appends the specified element to the end of this list. | |
393 | - * | |
394 | - * @param e element to be appended to this list | |
395 | - * @return <tt>true</tt> (as specified by {@link Collection#add}) | |
396 | - */ | |
397 | - public boolean add(E e) { | |
398 | - final ReentrantLock lock = this.lock; | |
381 | + public boolean removeAll(Collection<?> c) { | |
399 | 382 | lock.lock(); |
400 | 383 | try { |
401 | - Object[] elements = getArray(); | |
402 | - int len = elements.length; | |
403 | - Object[] newElements = Java6Arrays.copyOf(elements, len + 1); | |
404 | - newElements[len] = e; | |
405 | - setArray(newElements); | |
406 | - return true; | |
384 | + return removeAll(c, 0, getData().length) != 0; | |
407 | 385 | } finally { |
408 | 386 | lock.unlock(); |
409 | 387 | } |
410 | 388 | } |
411 | 389 | |
412 | - /** | |
413 | - * Inserts the specified element at the specified position in this | |
414 | - * list. Shifts the element currently at that position (if any) and | |
415 | - * any subsequent elements to the right (adds one to their indices). | |
416 | - * | |
417 | - * @throws IndexOutOfBoundsException {@inheritDoc} | |
418 | - */ | |
419 | - public void add(int index, E element) { | |
420 | - final ReentrantLock lock = this.lock; | |
390 | + public boolean retainAll(Collection<?> c) { | |
391 | + if (c == null) { | |
392 | + throw new NullPointerException(); | |
393 | + } | |
421 | 394 | lock.lock(); |
422 | 395 | try { |
423 | - Object[] elements = getArray(); | |
424 | - int len = elements.length; | |
425 | - if (index > len || index < 0) | |
426 | - throw new IndexOutOfBoundsException("Index: "+index+ | |
427 | - ", Size: "+len); | |
428 | - Object[] newElements; | |
429 | - int numMoved = len - index; | |
430 | - if (numMoved == 0) | |
431 | - newElements = Java6Arrays.copyOf(elements, len + 1); | |
432 | - else { | |
433 | - newElements = new Object[len + 1]; | |
434 | - System.arraycopy(elements, 0, newElements, 0, index); | |
435 | - System.arraycopy(elements, index, newElements, index + 1, | |
436 | - numMoved); | |
437 | - } | |
438 | - newElements[index] = element; | |
439 | - setArray(newElements); | |
396 | + return retainAll(c, 0, getData().length) != 0; | |
440 | 397 | } finally { |
441 | 398 | lock.unlock(); |
442 | 399 | } |
443 | 400 | } |
444 | 401 | |
445 | - /** | |
446 | - * Removes the element at the specified position in this list. | |
447 | - * Shifts any subsequent elements to the left (subtracts one from their | |
448 | - * indices). Returns the element that was removed from the list. | |
449 | - * | |
450 | - * @throws IndexOutOfBoundsException {@inheritDoc} | |
451 | - */ | |
452 | - public E remove(int index) { | |
453 | - final ReentrantLock lock = this.lock; | |
402 | + public E set(int index, E e) { | |
454 | 403 | lock.lock(); |
455 | 404 | try { |
456 | - Object[] elements = getArray(); | |
457 | - int len = elements.length; | |
458 | - E oldValue = get(elements, index); | |
459 | - int numMoved = len - index - 1; | |
460 | - if (numMoved == 0) | |
461 | - setArray(Java6Arrays.copyOf(elements, len - 1)); | |
462 | - else { | |
463 | - Object[] newElements = new Object[len - 1]; | |
464 | - System.arraycopy(elements, 0, newElements, 0, index); | |
465 | - System.arraycopy(elements, index + 1, newElements, index, | |
466 | - numMoved); | |
467 | - setArray(newElements); | |
468 | - } | |
469 | - return oldValue; | |
405 | + int size = size(); | |
406 | + checkIndexExlusive(index, size); | |
407 | + E[] data; | |
408 | + data = newElementArray(size); | |
409 | + E[] oldArr = getData(); | |
410 | + System.arraycopy(oldArr, 0, data, 0, size); | |
411 | + E old = data[index]; | |
412 | + data[index] = e; | |
413 | + setData(data); | |
414 | + return old; | |
470 | 415 | } finally { |
471 | 416 | lock.unlock(); |
472 | 417 | } |
473 | 418 | } |
474 | 419 | |
475 | - /** | |
476 | - * Removes the first occurrence of the specified element from this list, | |
477 | - * if it is present. If this list does not contain the element, it is | |
478 | - * unchanged. More formally, removes the element with the lowest index | |
479 | - * <tt>i</tt> such that | |
480 | - * <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt> | |
481 | - * (if such an element exists). Returns <tt>true</tt> if this list | |
482 | - * contained the specified element (or equivalently, if this list | |
483 | - * changed as a result of the call). | |
484 | - * | |
485 | - * @param o element to be removed from this list, if present | |
486 | - * @return <tt>true</tt> if this list contained the specified element | |
487 | - */ | |
488 | - public boolean remove(Object o) { | |
489 | - final ReentrantLock lock = this.lock; | |
490 | - lock.lock(); | |
491 | - try { | |
492 | - Object[] elements = getArray(); | |
493 | - int len = elements.length; | |
494 | - if (len != 0) { | |
495 | - // Copy while searching for element to remove | |
496 | - // This wins in the normal case of element being present | |
497 | - int newlen = len - 1; | |
498 | - Object[] newElements = new Object[newlen]; | |
499 | - | |
500 | - for (int i = 0; i < newlen; ++i) { | |
501 | - if (eq(o, elements[i])) { | |
502 | - // found one; copy remaining and exit | |
503 | - for (int k = i + 1; k < len; ++k) | |
504 | - newElements[k-1] = elements[k]; | |
505 | - setArray(newElements); | |
506 | - return true; | |
507 | - } else | |
508 | - newElements[i] = elements[i]; | |
509 | - } | |
420 | + public int size() { | |
421 | + return getData().length; | |
422 | + } | |
510 | 423 | |
511 | - // special handling for last cell | |
512 | - if (eq(o, elements[newlen])) { | |
513 | - setArray(newElements); | |
514 | - return true; | |
515 | - } | |
516 | - } | |
517 | - return false; | |
518 | - } finally { | |
519 | - lock.unlock(); | |
520 | - } | |
424 | + public List<E> subList(int fromIndex, int toIndex) { | |
425 | + return new SubList(this, fromIndex, toIndex); | |
521 | 426 | } |
522 | 427 | |
523 | - /** | |
524 | - * Removes from this list all of the elements whose index is between | |
525 | - * <tt>fromIndex</tt>, inclusive, and <tt>toIndex</tt>, exclusive. | |
526 | - * Shifts any succeeding elements to the left (reduces their index). | |
527 | - * This call shortens the list by <tt>(toIndex - fromIndex)</tt> elements. | |
528 | - * (If <tt>toIndex==fromIndex</tt>, this operation has no effect.) | |
529 | - * | |
530 | - * @param fromIndex index of first element to be removed | |
531 | - * @param toIndex index after last element to be removed | |
532 | - * @throws IndexOutOfBoundsException if fromIndex or toIndex out of range | |
533 | - * (@code{fromIndex < 0 || toIndex > size() || toIndex < fromIndex}) | |
534 | - */ | |
535 | - private void removeRange(int fromIndex, int toIndex) { | |
536 | - final ReentrantLock lock = this.lock; | |
537 | - lock.lock(); | |
538 | - try { | |
539 | - Object[] elements = getArray(); | |
540 | - int len = elements.length; | |
541 | - | |
542 | - if (fromIndex < 0 || toIndex > len || toIndex < fromIndex) | |
543 | - throw new IndexOutOfBoundsException(); | |
544 | - int newlen = len - (toIndex - fromIndex); | |
545 | - int numMoved = len - toIndex; | |
546 | - if (numMoved == 0) | |
547 | - setArray(Java6Arrays.copyOf(elements, newlen)); | |
548 | - else { | |
549 | - Object[] newElements = new Object[newlen]; | |
550 | - System.arraycopy(elements, 0, newElements, 0, fromIndex); | |
551 | - System.arraycopy(elements, toIndex, newElements, | |
552 | - fromIndex, numMoved); | |
553 | - setArray(newElements); | |
554 | - } | |
555 | - } finally { | |
556 | - lock.unlock(); | |
557 | - } | |
428 | + public Object[] toArray() { | |
429 | + E[] data = getData(); | |
430 | + return toArray(data, 0, data.length); | |
558 | 431 | } |
559 | 432 | |
560 | - /** | |
561 | - * Append the element if not present. | |
562 | - * | |
563 | - * @param e element to be added to this list, if absent | |
564 | - * @return <tt>true</tt> if the element was added | |
565 | - */ | |
566 | - public boolean addIfAbsent(E e) { | |
567 | - final ReentrantLock lock = this.lock; | |
568 | - lock.lock(); | |
569 | - try { | |
570 | - // Copy while checking if already present. | |
571 | - // This wins in the most common case where it is not present | |
572 | - Object[] elements = getArray(); | |
573 | - int len = elements.length; | |
574 | - Object[] newElements = new Object[len + 1]; | |
575 | - for (int i = 0; i < len; ++i) { | |
576 | - if (eq(e, elements[i])) | |
577 | - return false; // exit, throwing away copy | |
578 | - else | |
579 | - newElements[i] = elements[i]; | |
580 | - } | |
581 | - newElements[len] = e; | |
582 | - setArray(newElements); | |
583 | - return true; | |
584 | - } finally { | |
585 | - lock.unlock(); | |
433 | + public <T> T[] toArray(T[] a) { | |
434 | + E[] data = getData(); | |
435 | + return (T[]) toArray(a, data, 0, data.length); | |
436 | + } | |
437 | + | |
438 | + @Override | |
439 | + public String toString() { | |
440 | + StringBuilder sb = new StringBuilder("["); | |
441 | + | |
442 | + Iterator it = listIterator(); | |
443 | + while (it.hasNext()) { | |
444 | + sb.append(String.valueOf(it.next())); | |
445 | + sb.append(", "); | |
586 | 446 | } |
447 | + if (sb.length() > 1) { | |
448 | + sb.setLength(sb.length() - 2); | |
449 | + } | |
450 | + sb.append("]"); | |
451 | + return sb.toString(); | |
452 | + } | |
453 | + | |
454 | + // private and package private methods | |
455 | + | |
456 | + @SuppressWarnings("unchecked") | |
457 | + private final E[] newElementArray(int size) { | |
458 | + return (E[])new Object[size]; | |
587 | 459 | } |
588 | 460 | |
589 | 461 | /** |
590 | - * Returns <tt>true</tt> if this list contains all of the elements of the | |
591 | - * specified collection. | |
462 | + * sets the internal data array | |
592 | 463 | * |
593 | - * @param c collection to be checked for containment in this list | |
594 | - * @return <tt>true</tt> if this list contains all of the elements of the | |
595 | - * specified collection | |
596 | - * @throws NullPointerException if the specified collection is null | |
597 | - * @see #contains(Object) | |
464 | + * @param data array to set | |
598 | 465 | */ |
599 | - public boolean containsAll(Collection<?> c) { | |
600 | - Object[] elements = getArray(); | |
601 | - int len = elements.length; | |
602 | - for (Object e : c) { | |
603 | - if (indexOf(e, elements, 0, len) < 0) | |
604 | - return false; | |
605 | - } | |
606 | - return true; | |
466 | + private final void setData(E[] data) { | |
467 | + arr = data; | |
607 | 468 | } |
608 | 469 | |
609 | 470 | /** |
610 | - * Removes from this list all of its elements that are contained in | |
611 | - * the specified collection. This is a particularly expensive operation | |
612 | - * in this class because of the need for an internal temporary array. | |
471 | + * gets the internal data array (or a new array if it is null) | |
613 | 472 | * |
614 | - * @param c collection containing elements to be removed from this list | |
615 | - * @return <tt>true</tt> if this list changed as a result of the call | |
616 | - * @throws ClassCastException if the class of an element of this list | |
617 | - * is incompatible with the specified collection (optional) | |
618 | - * @throws NullPointerException if this list contains a null element and the | |
619 | - * specified collection does not permit null elements (optional), | |
620 | - * or if the specified collection is null | |
621 | - * @see #remove(Object) | |
473 | + * @return the data array | |
622 | 474 | */ |
623 | - public boolean removeAll(Collection<?> c) { | |
624 | - final ReentrantLock lock = this.lock; | |
625 | - lock.lock(); | |
626 | - try { | |
627 | - Object[] elements = getArray(); | |
628 | - int len = elements.length; | |
629 | - if (len != 0) { | |
630 | - // temp array holds those elements we know we want to keep | |
631 | - int newlen = 0; | |
632 | - Object[] temp = new Object[len]; | |
633 | - for (int i = 0; i < len; ++i) { | |
634 | - Object element = elements[i]; | |
635 | - if (!c.contains(element)) | |
636 | - temp[newlen++] = element; | |
637 | - } | |
638 | - if (newlen != len) { | |
639 | - setArray(Java6Arrays.copyOf(temp, newlen)); | |
640 | - return true; | |
641 | - } | |
642 | - } | |
643 | - return false; | |
644 | - } finally { | |
645 | - lock.unlock(); | |
475 | + final E[] getData() { | |
476 | + if (arr == null) { | |
477 | + return newElementArray(0); | |
646 | 478 | } |
479 | + return arr; | |
647 | 480 | } |
648 | 481 | |
649 | 482 | /** |
650 | - * Retains only the elements in this list that are contained in the | |
651 | - * specified collection. In other words, removes from this list all of | |
652 | - * its elements that are not contained in the specified collection. | |
483 | + * Removes from the specified range of this list | |
484 | + * all the elements that are contained in the specified collection | |
485 | + * <p/> | |
486 | + * !should be called under lock | |
653 | 487 | * |
654 | - * @param c collection containing elements to be retained in this list | |
655 | - * @return <tt>true</tt> if this list changed as a result of the call | |
656 | - * @throws ClassCastException if the class of an element of this list | |
657 | - * is incompatible with the specified collection (optional) | |
658 | - * @throws NullPointerException if this list contains a null element and the | |
659 | - * specified collection does not permit null elements (optional), | |
660 | - * or if the specified collection is null | |
661 | - * @see #remove(Object) | |
488 | + * @return Returns the number of removed elements | |
662 | 489 | */ |
663 | - public boolean retainAll(Collection<?> c) { | |
664 | - final ReentrantLock lock = this.lock; | |
665 | - lock.lock(); | |
666 | - try { | |
667 | - Object[] elements = getArray(); | |
668 | - int len = elements.length; | |
669 | - if (len != 0) { | |
670 | - // temp array holds those elements we know we want to keep | |
671 | - int newlen = 0; | |
672 | - Object[] temp = new Object[len]; | |
673 | - for (int i = 0; i < len; ++i) { | |
674 | - Object element = elements[i]; | |
675 | - if (c.contains(element)) | |
676 | - temp[newlen++] = element; | |
677 | - } | |
678 | - if (newlen != len) { | |
679 | - setArray(Java6Arrays.copyOf(temp, newlen)); | |
680 | - return true; | |
681 | - } | |
490 | + final int removeAll(Collection c, int start, int size) { | |
491 | + int ssize = c.size(); | |
492 | + if (ssize == 0) { | |
493 | + return 0; | |
494 | + } | |
495 | + Object[] old = getData(); | |
496 | + int arrsize = old.length; | |
497 | + if (arrsize == 0) { | |
498 | + return 0; | |
499 | + } | |
500 | + Object[] data = new Object[size]; | |
501 | + int j = 0; | |
502 | + for (int i = start; i < (start + size); i++) { | |
503 | + if (!c.contains(old[i])) { | |
504 | + data[j++] = old[i]; | |
682 | 505 | } |
683 | - return false; | |
684 | - } finally { | |
685 | - lock.unlock(); | |
686 | 506 | } |
507 | + if (j != size) { | |
508 | + E[] result = newElementArray(arrsize - (size - j)); | |
509 | + System.arraycopy(old, 0, result, 0, start); | |
510 | + System.arraycopy(data, 0, result, start, j); | |
511 | + System.arraycopy(old, start + size, result, start + j, arrsize | |
512 | + - (start + size)); | |
513 | + setData(result); | |
514 | + return (size - j); | |
515 | + } | |
516 | + return 0; | |
687 | 517 | } |
688 | 518 | |
689 | 519 | /** |
690 | - * Appends all of the elements in the specified collection that | |
691 | - * are not already contained in this list, to the end of | |
692 | - * this list, in the order that they are returned by the | |
693 | - * specified collection's iterator. | |
520 | + * Retains only the elements in the specified range of this list | |
521 | + * that are contained in the specified collection | |
694 | 522 | * |
695 | - * @param c collection containing elements to be added to this list | |
696 | - * @return the number of elements added | |
697 | - * @throws NullPointerException if the specified collection is null | |
698 | - * @see #addIfAbsent(Object) | |
523 | + * @return Returns the number of removed elements | |
699 | 524 | */ |
700 | - public int addAllAbsent(Collection<? extends E> c) { | |
701 | - Object[] cs = c.toArray(); | |
702 | - if (cs.length == 0) | |
525 | + // should be called under lock | |
526 | + int retainAll(Collection c, int start, int size) { | |
527 | + Object[] old = getData(); | |
528 | + if (size == 0) { | |
703 | 529 | return 0; |
704 | - Object[] uniq = new Object[cs.length]; | |
705 | - final ReentrantLock lock = this.lock; | |
706 | - lock.lock(); | |
707 | - try { | |
708 | - Object[] elements = getArray(); | |
709 | - int len = elements.length; | |
710 | - int added = 0; | |
711 | - for (int i = 0; i < cs.length; ++i) { // scan for duplicates | |
712 | - Object e = cs[i]; | |
713 | - if (indexOf(e, elements, 0, len) < 0 && | |
714 | - indexOf(e, uniq, 0, added) < 0) | |
715 | - uniq[added++] = e; | |
530 | + } | |
531 | + if (c.size() == 0) { | |
532 | + E[] data; | |
533 | + if (size == old.length) { | |
534 | + data = newElementArray(0); | |
535 | + } else { | |
536 | + data = newElementArray(old.length - size); | |
537 | + System.arraycopy(old, 0, data, 0, start); | |
538 | + System.arraycopy(old, start + size, data, start, old.length | |
539 | + - start - size); | |
716 | 540 | } |
717 | - if (added > 0) { | |
718 | - Object[] newElements = Java6Arrays.copyOf(elements, len + added); | |
719 | - System.arraycopy(uniq, 0, newElements, len, added); | |
720 | - setArray(newElements); | |
541 | + setData(data); | |
542 | + return size; | |
543 | + } | |
544 | + Object[] temp = new Object[size]; | |
545 | + int pos = 0; | |
546 | + for (int i = start; i < (start + size); i++) { | |
547 | + if (c.contains(old[i])) { | |
548 | + temp[pos++] = old[i]; | |
721 | 549 | } |
722 | - return added; | |
723 | - } finally { | |
724 | - lock.unlock(); | |
725 | 550 | } |
551 | + if (pos == size) { | |
552 | + return 0; | |
553 | + } | |
554 | + E[] data = newElementArray(pos + old.length - size); | |
555 | + System.arraycopy(old, 0, data, 0, start); | |
556 | + System.arraycopy(temp, 0, data, start, pos); | |
557 | + System.arraycopy(old, start + size, data, start + pos, old.length | |
558 | + - start - size); | |
559 | + setData(data); | |
560 | + return (size - pos); | |
726 | 561 | } |
727 | 562 | |
728 | 563 | /** |
729 | - * Removes all of the elements from this list. | |
730 | - * The list will be empty after this call returns. | |
564 | + * Removes specified range from this list | |
731 | 565 | */ |
732 | - public void clear() { | |
733 | - final ReentrantLock lock = this.lock; | |
566 | + E removeRange(int start, int size) { | |
734 | 567 | lock.lock(); |
735 | 568 | try { |
736 | - setArray(new Object[0]); | |
569 | + int sizeArr = size(); | |
570 | + checkIndexExlusive(start, sizeArr); | |
571 | + checkIndexInclusive(start + size, sizeArr); | |
572 | + E[] data; | |
573 | + data = newElementArray(sizeArr - size); | |
574 | + E[] oldArr = getData(); | |
575 | + System.arraycopy(oldArr, 0, data, 0, start); | |
576 | + E old = oldArr[start]; | |
577 | + if (sizeArr > (start + size)) { | |
578 | + System.arraycopy(oldArr, start + size, data, start, sizeArr | |
579 | + - (start + size)); | |
580 | + } | |
581 | + setData(data); | |
582 | + return old; | |
737 | 583 | } finally { |
738 | 584 | lock.unlock(); |
739 | 585 | } |
740 | 586 | } |
741 | 587 | |
588 | + // some util static functions to use by iterators and methods | |
742 | 589 | /** |
743 | - * Appends all of the elements in the specified collection to the end | |
744 | - * of this list, in the order that they are returned by the specified | |
745 | - * collection's iterator. | |
746 | - * | |
747 | - * @param c collection containing elements to be added to this list | |
748 | - * @return <tt>true</tt> if this list changed as a result of the call | |
749 | - * @throws NullPointerException if the specified collection is null | |
750 | - * @see #add(Object) | |
590 | + * Returns an array containing all of the elements | |
591 | + * in the specified range of the array in proper sequence | |
751 | 592 | */ |
752 | - public boolean addAll(Collection<? extends E> c) { | |
753 | - Object[] cs = c.toArray(); | |
754 | - if (cs.length == 0) | |
755 | - return false; | |
756 | - final ReentrantLock lock = this.lock; | |
757 | - lock.lock(); | |
758 | - try { | |
759 | - Object[] elements = getArray(); | |
760 | - int len = elements.length; | |
761 | - Object[] newElements = Java6Arrays.copyOf(elements, len + cs.length); | |
762 | - System.arraycopy(cs, 0, newElements, len, cs.length); | |
763 | - setArray(newElements); | |
764 | - return true; | |
765 | - } finally { | |
766 | - lock.unlock(); | |
767 | - } | |
593 | + static Object[] toArray(Object[] data, int start, int size) { | |
594 | + Object[] result = new Object[size]; | |
595 | + System.arraycopy(data, start, result, 0, size); | |
596 | + return result; | |
768 | 597 | } |
769 | 598 | |
770 | 599 | /** |
771 | - * Inserts all of the elements in the specified collection into this | |
772 | - * list, starting at the specified position. Shifts the element | |
773 | - * currently at that position (if any) and any subsequent elements to | |
774 | - * the right (increases their indices). The new elements will appear | |
775 | - * in this list in the order that they are returned by the | |
776 | - * specified collection's iterator. | |
777 | - * | |
778 | - * @param index index at which to insert the first element | |
779 | - * from the specified collection | |
780 | - * @param c collection containing elements to be added to this list | |
781 | - * @return <tt>true</tt> if this list changed as a result of the call | |
782 | - * @throws IndexOutOfBoundsException {@inheritDoc} | |
783 | - * @throws NullPointerException if the specified collection is null | |
784 | - * @see #add(int,Object) | |
600 | + * Returns an array containing all of the elements | |
601 | + * in the specified range of the array in proper sequence, | |
602 | + * stores the result in the array, specified by first parameter | |
603 | + * (as for public instance method toArray(Object[] to) | |
785 | 604 | */ |
786 | - public boolean addAll(int index, Collection<? extends E> c) { | |
787 | - Object[] cs = c.toArray(); | |
788 | - final ReentrantLock lock = this.lock; | |
789 | - lock.lock(); | |
790 | - try { | |
791 | - Object[] elements = getArray(); | |
792 | - int len = elements.length; | |
793 | - if (index > len || index < 0) | |
794 | - throw new IndexOutOfBoundsException("Index: "+index+ | |
795 | - ", Size: "+len); | |
796 | - if (cs.length == 0) | |
797 | - return false; | |
798 | - int numMoved = len - index; | |
799 | - Object[] newElements; | |
800 | - if (numMoved == 0) | |
801 | - newElements = Java6Arrays.copyOf(elements, len + cs.length); | |
802 | - else { | |
803 | - newElements = new Object[len + cs.length]; | |
804 | - System.arraycopy(elements, 0, newElements, 0, index); | |
805 | - System.arraycopy(elements, index, | |
806 | - newElements, index + cs.length, | |
807 | - numMoved); | |
605 | + static Object[] toArray(Object[] to, Object[] data, int start, int size) { | |
606 | + int l = data.length; | |
607 | + if (to.length < l) { | |
608 | + to = (Object[]) Array.newInstance(to.getClass().getComponentType(), | |
609 | + l); | |
610 | + } else { | |
611 | + if (to.length > l) { | |
612 | + to[l] = null; | |
808 | 613 | } |
809 | - System.arraycopy(cs, 0, newElements, index, cs.length); | |
810 | - setArray(newElements); | |
811 | - return true; | |
812 | - } finally { | |
813 | - lock.unlock(); | |
814 | 614 | } |
615 | + System.arraycopy(data, start, to, 0, size); | |
616 | + return to; | |
815 | 617 | } |
816 | 618 | |
817 | 619 | /** |
818 | - * Save the state of the list to a stream (i.e., serialize it). | |
620 | + * Checks if the specified range of the | |
621 | + * array contains all of the elements in the collection | |
819 | 622 | * |
820 | - * @serialData The length of the array backing the list is emitted | |
821 | - * (int), followed by all of its elements (each an Object) | |
822 | - * in the proper order. | |
823 | - * @param s the stream | |
623 | + * @param c collection with elements | |
624 | + * @param data array where to search the elements | |
625 | + * @param start start index | |
626 | + * @param size size of the range | |
824 | 627 | */ |
825 | - private void writeObject(java.io.ObjectOutputStream s) | |
826 | - throws java.io.IOException{ | |
827 | - | |
828 | - // Write out element count, and any hidden stuff | |
829 | - s.defaultWriteObject(); | |
830 | - | |
831 | - Object[] elements = getArray(); | |
832 | - int len = elements.length; | |
833 | - // Write out array length | |
834 | - s.writeInt(len); | |
835 | - | |
836 | - // Write out all elements in the proper order. | |
837 | - for (int i = 0; i < len; i++) | |
838 | - s.writeObject(elements[i]); | |
839 | - } | |
840 | - | |
841 | - /** | |
842 | - * Reconstitute the list from a stream (i.e., deserialize it). | |
843 | - * @param s the stream | |
844 | - */ | |
845 | - private void readObject(java.io.ObjectInputStream s) | |
846 | - throws java.io.IOException, ClassNotFoundException { | |
847 | - | |
848 | - // Read in size, and any hidden stuff | |
849 | - s.defaultReadObject(); | |
850 | - | |
851 | - // bind to new lock | |
852 | - resetLock(); | |
853 | - | |
854 | - // Read in array length and allocate array | |
855 | - int len = s.readInt(); | |
856 | - Object[] elements = new Object[len]; | |
857 | - | |
858 | - // Read in all elements in the proper order. | |
859 | - for (int i = 0; i < len; i++) | |
860 | - elements[i] = s.readObject(); | |
861 | - setArray(elements); | |
628 | + static final boolean containsAll(Collection c, Object[] data, int start, | |
629 | + int size) { | |
630 | + if (size == 0) { | |
631 | + return false; | |
632 | + } | |
633 | + Iterator it = c.iterator(); | |
634 | + while (it.hasNext()) { | |
635 | + Object next = it.next(); | |
636 | + if (indexOf(next, data, start, size) < 0) { | |
637 | + return false; | |
638 | + } | |
639 | + } | |
640 | + return true; | |
862 | 641 | } |
863 | 642 | |
864 | 643 | /** |
865 | - * Returns a string representation of this list. The string | |
866 | - * representation consists of the string representations of the list's | |
867 | - * elements in the order they are returned by its iterator, enclosed in | |
868 | - * square brackets (<tt>"[]"</tt>). Adjacent elements are separated by | |
869 | - * the characters <tt>", "</tt> (comma and space). Elements are | |
870 | - * converted to strings as by {@link String#valueOf(Object)}. | |
644 | + * Returns the index in the specified range of the data array | |
645 | + * of the last occurrence of the specified element | |
871 | 646 | * |
872 | - * @return a string representation of this list | |
647 | + * @param o element to search | |
648 | + * @param data array where to search | |
649 | + * @param start start index | |
650 | + * @param size size of the range | |
651 | + * @return | |
873 | 652 | */ |
874 | - public String toString() { | |
875 | - return Arrays.toString(getArray()); | |
653 | + static final int lastIndexOf(Object o, Object[] data, int start, int size) { | |
654 | + if (size == 0) { | |
655 | + return -1; | |
656 | + } | |
657 | + if (o != null) { | |
658 | + for (int i = start + size - 1; i > start - 1; i--) { | |
659 | + if (o.equals(data[i])) { | |
660 | + return i; | |
661 | + } | |
662 | + } | |
663 | + } else { | |
664 | + for (int i = start + size - 1; i > start - 1; i--) { | |
665 | + if (data[i] == null) { | |
666 | + return i; | |
667 | + } | |
668 | + } | |
669 | + } | |
670 | + return -1; | |
876 | 671 | } |
877 | 672 | |
878 | 673 | /** |
879 | - * Compares the specified object with this list for equality. | |
880 | - * Returns {@code true} if the specified object is the same object | |
881 | - * as this object, or if it is also a {@link List} and the sequence | |
882 | - * of elements returned by an {@linkplain List#iterator() iterator} | |
883 | - * over the specified list is the same as the sequence returned by | |
884 | - * an iterator over this list. The two sequences are considered to | |
885 | - * be the same if they have the same length and corresponding | |
886 | - * elements at the same position in the sequence are <em>equal</em>. | |
887 | - * Two elements {@code e1} and {@code e2} are considered | |
888 | - * <em>equal</em> if {@code (e1==null ? e2==null : e1.equals(e2))}. | |
674 | + * Returns the index in the specified range of the data array | |
675 | + * of the first occurrence of the specified element | |
889 | 676 | * |
890 | - * @param o the object to be compared for equality with this list | |
891 | - * @return {@code true} if the specified object is equal to this list | |
677 | + * @param o element to search | |
678 | + * @param data array where to search | |
679 | + * @param start start index | |
680 | + * @param size end index | |
681 | + * @return | |
892 | 682 | */ |
893 | - public boolean equals(Object o) { | |
894 | - if (o == this) | |
895 | - return true; | |
896 | - if (!(o instanceof List)) | |
897 | - return false; | |
898 | - | |
899 | - List<?> list = (List<?>)(o); | |
900 | - Iterator<?> it = list.iterator(); | |
901 | - Object[] elements = getArray(); | |
902 | - int len = elements.length; | |
903 | - for (int i = 0; i < len; ++i) | |
904 | - if (!it.hasNext() || !eq(elements[i], it.next())) | |
905 | - return false; | |
906 | - if (it.hasNext()) | |
907 | - return false; | |
908 | - return true; | |
683 | + static final int indexOf(Object o, Object[] data, int start, int size) { | |
684 | + if (size == 0) { | |
685 | + return -1; | |
686 | + } | |
687 | + if (o == null) { | |
688 | + for (int i = start; i < start + size; i++) { | |
689 | + if (data[i] == null) { | |
690 | + return i; | |
691 | + } | |
692 | + } | |
693 | + } else { | |
694 | + for (int i = start; i < start + size; i++) { | |
695 | + if (o.equals(data[i])) { | |
696 | + return i; | |
697 | + } | |
698 | + } | |
699 | + } | |
700 | + return -1; | |
909 | 701 | } |
910 | 702 | |
911 | 703 | /** |
912 | - * Returns the hash code value for this list. | |
913 | - * | |
914 | - * <p>This implementation uses the definition in {@link List#hashCode}. | |
704 | + * Throws <code>IndexOutOfBoundsException</code> if <code>index</code> | |
705 | + * is out of the list bounds. | |
915 | 706 | * |
916 | - * @return the hash code value for this list | |
707 | + * @param index element index to check. | |
917 | 708 | */ |
918 | - public int hashCode() { | |
919 | - int hashCode = 1; | |
920 | - Object[] elements = getArray(); | |
921 | - int len = elements.length; | |
922 | - for (int i = 0; i < len; ++i) { | |
923 | - Object obj = elements[i]; | |
924 | - hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode()); | |
709 | + static final void checkIndexInclusive(int index, int size) { | |
710 | + if (index < 0 || index > size) { | |
711 | + throw new IndexOutOfBoundsException("Index is " + index + ", size is " + size); | |
925 | 712 | } |
926 | - return hashCode; | |
927 | 713 | } |
928 | 714 | |
929 | 715 | /** |
930 | - * Returns an iterator over the elements in this list in proper sequence. | |
716 | + * Throws <code>IndexOutOfBoundsException</code> if <code>index</code> | |
717 | + * is out of the list bounds. Excluding the last element. | |
931 | 718 | * |
932 | - * <p>The returned iterator provides a snapshot of the state of the list | |
933 | - * when the iterator was constructed. No synchronization is needed while | |
934 | - * traversing the iterator. The iterator does <em>NOT</em> support the | |
935 | - * <tt>remove</tt> method. | |
936 | - * | |
937 | - * @return an iterator over the elements in this list in proper sequence | |
719 | + * @param index element index to check. | |
938 | 720 | */ |
939 | - public Iterator<E> iterator() { | |
940 | - return new COWIterator<E>(getArray(), 0); | |
721 | + static final void checkIndexExlusive(int index, int size) { | |
722 | + if (index < 0 || index >= size) { | |
723 | + throw new IndexOutOfBoundsException("Index is " + index + ", size is " + size); | |
724 | + } | |
941 | 725 | } |
942 | 726 | |
943 | 727 | /** |
944 | - * {@inheritDoc} | |
728 | + * gets the internal data array | |
945 | 729 | * |
946 | - * <p>The returned iterator provides a snapshot of the state of the list | |
947 | - * when the iterator was constructed. No synchronization is needed while | |
948 | - * traversing the iterator. The iterator does <em>NOT</em> support the | |
949 | - * <tt>remove</tt>, <tt>set</tt> or <tt>add</tt> methods. | |
730 | + * @return the data array | |
950 | 731 | */ |
951 | - public ListIterator<E> listIterator() { | |
952 | - return new COWIterator<E>(getArray(), 0); | |
732 | + final E[] getArray() { | |
733 | + return arr; | |
953 | 734 | } |
954 | 735 | |
955 | 736 | /** |
956 | - * {@inheritDoc} | |
957 | - * | |
958 | - * <p>The returned iterator provides a snapshot of the state of the list | |
959 | - * when the iterator was constructed. No synchronization is needed while | |
960 | - * traversing the iterator. The iterator does <em>NOT</em> support the | |
961 | - * <tt>remove</tt>, <tt>set</tt> or <tt>add</tt> methods. | |
962 | - * | |
963 | - * @throws IndexOutOfBoundsException {@inheritDoc} | |
737 | + * list iterator implementation, | |
738 | + * when created gets snapshot of the list, | |
739 | + * so never throws ConcurrentModificationException | |
964 | 740 | */ |
965 | - public ListIterator<E> listIterator(final int index) { | |
966 | - Object[] elements = getArray(); | |
967 | - int len = elements.length; | |
968 | - if (index<0 || index>len) | |
969 | - throw new IndexOutOfBoundsException("Index: "+index); | |
741 | + private static class ListIteratorImpl implements ListIterator { | |
742 | + private final Object[] arr; | |
970 | 743 | |
971 | - return new COWIterator<E>(elements, index); | |
972 | - } | |
744 | + private int current; | |
973 | 745 | |
974 | - private static class COWIterator<E> implements ListIterator<E> { | |
975 | - /** Snapshot of the array **/ | |
976 | - private final Object[] snapshot; | |
977 | - /** Index of element to be returned by subsequent call to next. */ | |
978 | - private int cursor; | |
746 | + private final int size; | |
979 | 747 | |
980 | - private COWIterator(Object[] elements, int initialCursor) { | |
981 | - cursor = initialCursor; | |
982 | - snapshot = elements; | |
748 | + final int size() { | |
749 | + return size; | |
750 | + } | |
751 | + | |
752 | + public ListIteratorImpl(Object[] data, int current) { | |
753 | + this.current = current; | |
754 | + arr = data; | |
755 | + size = data.length; | |
756 | + } | |
757 | + | |
758 | + public void add(Object o) { | |
759 | + throw new UnsupportedOperationException("Unsupported operation add"); | |
983 | 760 | } |
984 | 761 | |
985 | 762 | public boolean hasNext() { |
986 | - return cursor < snapshot.length; | |
763 | + if (current < size) { | |
764 | + return true; | |
765 | + } | |
766 | + return false; | |
987 | 767 | } |
988 | 768 | |
989 | 769 | public boolean hasPrevious() { |
990 | - return cursor > 0; | |
770 | + return current > 0; | |
991 | 771 | } |
992 | 772 | |
993 | - @SuppressWarnings("unchecked") | |
994 | - public E next() { | |
995 | - if (! hasNext()) | |
996 | - throw new NoSuchElementException(); | |
997 | - return (E) snapshot[cursor++]; | |
773 | + public Object next() { | |
774 | + if (hasNext()) { | |
775 | + return arr[current++]; | |
776 | + } | |
777 | + throw new NoSuchElementException("pos is " + current + ", size is " + size); | |
998 | 778 | } |
999 | 779 | |
1000 | - @SuppressWarnings("unchecked") | |
1001 | - public E previous() { | |
1002 | - if (! hasPrevious()) | |
1003 | - throw new NoSuchElementException(); | |
1004 | - return (E) snapshot[--cursor]; | |
780 | + public int nextIndex() { | |
781 | + return current; | |
1005 | 782 | } |
1006 | 783 | |
1007 | - public int nextIndex() { | |
1008 | - return cursor; | |
784 | + public Object previous() { | |
785 | + if (hasPrevious()) { | |
786 | + return arr[--current]; | |
787 | + } | |
788 | + throw new NoSuchElementException("pos is " + (current-1) + ", size is " + size); | |
1009 | 789 | } |
1010 | 790 | |
1011 | 791 | public int previousIndex() { |
1012 | - return cursor-1; | |
792 | + return current - 1; | |
1013 | 793 | } |
1014 | 794 | |
1015 | - /** | |
1016 | - * Not supported. Always throws UnsupportedOperationException. | |
1017 | - * @throws UnsupportedOperationException always; <tt>remove</tt> | |
1018 | - * is not supported by this iterator. | |
1019 | - */ | |
1020 | 795 | public void remove() { |
1021 | - throw new UnsupportedOperationException(); | |
796 | + throw new UnsupportedOperationException("Unsupported operation remove"); | |
1022 | 797 | } |
1023 | 798 | |
1024 | - /** | |
1025 | - * Not supported. Always throws UnsupportedOperationException. | |
1026 | - * @throws UnsupportedOperationException always; <tt>set</tt> | |
1027 | - * is not supported by this iterator. | |
1028 | - */ | |
1029 | - public void set(E e) { | |
1030 | - throw new UnsupportedOperationException(); | |
799 | + public void set(Object o) { | |
800 | + throw new UnsupportedOperationException("Unsupported operation set"); | |
1031 | 801 | } |
1032 | 802 | |
1033 | - /** | |
1034 | - * Not supported. Always throws UnsupportedOperationException. | |
1035 | - * @throws UnsupportedOperationException always; <tt>add</tt> | |
1036 | - * is not supported by this iterator. | |
1037 | - */ | |
1038 | - public void add(E e) { | |
1039 | - throw new UnsupportedOperationException(); | |
1040 | - } | |
1041 | 803 | } |
1042 | 804 | |
1043 | 805 | /** |
1044 | - * Returns a view of the portion of this list between | |
1045 | - * <tt>fromIndex</tt>, inclusive, and <tt>toIndex</tt>, exclusive. | |
1046 | - * The returned list is backed by this list, so changes in the | |
1047 | - * returned list are reflected in this list. | |
1048 | - * | |
1049 | - * <p>The semantics of the list returned by this method become | |
1050 | - * undefined if the backing list (i.e., this list) is modified in | |
1051 | - * any way other than via the returned list. | |
1052 | - * | |
1053 | - * @param fromIndex low endpoint (inclusive) of the subList | |
1054 | - * @param toIndex high endpoint (exclusive) of the subList | |
1055 | - * @return a view of the specified range within this list | |
1056 | - * @throws IndexOutOfBoundsException {@inheritDoc} | |
806 | + * Keeps a state of sublist implementation, | |
807 | + * size and array declared as final, | |
808 | + * so we'll never get the unconsistent state | |
1057 | 809 | */ |
1058 | - public List<E> subList(int fromIndex, int toIndex) { | |
1059 | - final ReentrantLock lock = this.lock; | |
1060 | - lock.lock(); | |
1061 | - try { | |
1062 | - Object[] elements = getArray(); | |
1063 | - int len = elements.length; | |
1064 | - if (fromIndex < 0 || toIndex > len || fromIndex > toIndex) | |
1065 | - throw new IndexOutOfBoundsException(); | |
1066 | - return new COWSubList<E>(this, fromIndex, toIndex); | |
1067 | - } finally { | |
1068 | - lock.unlock(); | |
810 | + static final class SubListReadData { | |
811 | + final int size; | |
812 | + | |
813 | + final Object[] data; | |
814 | + | |
815 | + SubListReadData(int size, Object[] data) { | |
816 | + this.size = size; | |
817 | + this.data = data; | |
1069 | 818 | } |
1070 | 819 | } |
1071 | 820 | |
1072 | 821 | /** |
1073 | - * Sublist for CopyOnWriteArrayList. | |
1074 | - * This class extends AbstractList merely for convenience, to | |
1075 | - * avoid having to define addAll, etc. This doesn't hurt, but | |
1076 | - * is wasteful. This class does not need or use modCount | |
1077 | - * mechanics in AbstractList, but does need to check for | |
1078 | - * concurrent modification using similar mechanics. On each | |
1079 | - * operation, the array that we expect the backing list to use | |
1080 | - * is checked and updated. Since we do this for all of the | |
1081 | - * base operations invoked by those defined in AbstractList, | |
1082 | - * all is well. While inefficient, this is not worth | |
1083 | - * improving. The kinds of list operations inherited from | |
1084 | - * AbstractList are already so slow on COW sublists that | |
1085 | - * adding a bit more space/time doesn't seem even noticeable. | |
822 | + * Represents a list returned by <code>sublist()</code>. | |
1086 | 823 | */ |
1087 | - private static class COWSubList<E> | |
1088 | - extends AbstractList<E> | |
1089 | - implements RandomAccess | |
1090 | - { | |
1091 | - private final CopyOnWriteArrayList<E> l; | |
1092 | - private final int offset; | |
1093 | - private int size; | |
1094 | - private Object[] expectedArray; | |
1095 | - | |
1096 | - // only call this holding l's lock | |
1097 | - COWSubList(CopyOnWriteArrayList<E> list, | |
1098 | - int fromIndex, int toIndex) { | |
1099 | - l = list; | |
1100 | - expectedArray = l.getArray(); | |
1101 | - offset = fromIndex; | |
1102 | - size = toIndex - fromIndex; | |
1103 | - } | |
1104 | - | |
1105 | - // only call this holding l's lock | |
1106 | - private void checkForComodification() { | |
1107 | - if (l.getArray() != expectedArray) | |
824 | + static class SubList implements List { | |
825 | + private final CopyOnWriteArrayList list; | |
826 | + | |
827 | + private volatile SubListReadData read; | |
828 | + | |
829 | + private final int start; | |
830 | + | |
831 | + /** | |
832 | + * Sublist constructor. | |
833 | + * | |
834 | + * @param list backing list. | |
835 | + * @param fromIdx startingIndex, inclusive | |
836 | + * @param toIdx endIndex, exclusive | |
837 | + */ | |
838 | + public SubList(CopyOnWriteArrayList list, int fromIdx, int toIdx) { | |
839 | + this.list = list; | |
840 | + Object[] data = list.getData(); | |
841 | + int size = toIdx - fromIdx; | |
842 | + checkIndexExlusive(fromIdx, data.length); | |
843 | + checkIndexInclusive(toIdx, data.length); | |
844 | + read = new SubListReadData(size, list.getData()); | |
845 | + start = fromIdx; | |
846 | + } | |
847 | + | |
848 | + /** | |
849 | + * throws ConcurrentModificationException when the list | |
850 | + * is structurally modified in the other way other than via this subList | |
851 | + * <p/> | |
852 | + * Should be called under lock! | |
853 | + */ | |
854 | + private void checkModifications() { | |
855 | + if (read.data != list.getData()) { | |
1108 | 856 | throw new ConcurrentModificationException(); |
857 | + } | |
1109 | 858 | } |
1110 | 859 | |
1111 | - // only call this holding l's lock | |
1112 | - private void rangeCheck(int index) { | |
1113 | - if (index<0 || index>=size) | |
1114 | - throw new IndexOutOfBoundsException("Index: "+index+ | |
1115 | - ",Size: "+size); | |
860 | + /** | |
861 | + * @see java.util.List#listIterator(int) | |
862 | + */ | |
863 | + public ListIterator listIterator(int startIdx) { | |
864 | + return new SubListIterator(startIdx, read); | |
1116 | 865 | } |
1117 | 866 | |
1118 | - public E set(int index, E element) { | |
1119 | - final ReentrantLock lock = l.lock; | |
1120 | - lock.lock(); | |
867 | + /** | |
868 | + * @see java.util.List#set(int, java.lang.Object) | |
869 | + */ | |
870 | + public Object set(int index, Object obj) { | |
871 | + list.lock.lock(); | |
1121 | 872 | try { |
1122 | - rangeCheck(index); | |
1123 | - checkForComodification(); | |
1124 | - E x = l.set(index+offset, element); | |
1125 | - expectedArray = l.getArray(); | |
1126 | - return x; | |
873 | + checkIndexExlusive(index, read.size); | |
874 | + checkModifications(); | |
875 | + Object result = list.set(index + start, obj); | |
876 | + read = new SubListReadData(read.size, list.getData()); | |
877 | + return result; | |
1127 | 878 | } finally { |
1128 | - lock.unlock(); | |
879 | + list.lock.unlock(); | |
1129 | 880 | } |
1130 | 881 | } |
1131 | 882 | |
1132 | - public E get(int index) { | |
1133 | - final ReentrantLock lock = l.lock; | |
1134 | - lock.lock(); | |
883 | + /** | |
884 | + * @see java.util.List#get(int) | |
885 | + */ | |
886 | + public Object get(int index) { | |
887 | + SubListReadData data = read; | |
888 | + if (data.data != list.getData()) { | |
889 | + list.lock.lock(); | |
890 | + try { | |
891 | + data = read; | |
892 | + if (data.data != list.getData()) { | |
893 | + throw new ConcurrentModificationException(); | |
894 | + } | |
895 | + } finally { | |
896 | + list.lock.unlock(); | |
897 | + } | |
898 | + } | |
899 | + checkIndexExlusive(index, data.size); | |
900 | + return data.data[index + start]; | |
901 | + } | |
902 | + | |
903 | + /** | |
904 | + * @see java.util.Collection#size() | |
905 | + */ | |
906 | + public int size() { | |
907 | + return read.size; | |
908 | + } | |
909 | + | |
910 | + /** | |
911 | + * @see java.util.List#remove(int) | |
912 | + */ | |
913 | + public Object remove(int index) { | |
914 | + list.lock.lock(); | |
1135 | 915 | try { |
1136 | - rangeCheck(index); | |
1137 | - checkForComodification(); | |
1138 | - return l.get(index+offset); | |
916 | + checkIndexExlusive(index, read.size); | |
917 | + checkModifications(); | |
918 | + Object obj = list.remove(index + start); | |
919 | + read = new SubListReadData(read.size - 1, list.getData()); | |
920 | + return obj; | |
1139 | 921 | } finally { |
1140 | - lock.unlock(); | |
922 | + list.lock.unlock(); | |
1141 | 923 | } |
1142 | 924 | } |
1143 | 925 | |
1144 | - public int size() { | |
1145 | - final ReentrantLock lock = l.lock; | |
1146 | - lock.lock(); | |
926 | + /** | |
927 | + * @see java.util.List#add(int, java.lang.Object) | |
928 | + */ | |
929 | + public void add(int index, Object object) { | |
930 | + list.lock.lock(); | |
1147 | 931 | try { |
1148 | - checkForComodification(); | |
1149 | - return size; | |
932 | + checkIndexInclusive(index, read.size); | |
933 | + checkModifications(); | |
934 | + list.add(index + start, object); | |
935 | + read = new SubListReadData(read.size + 1, list.getData()); | |
1150 | 936 | } finally { |
1151 | - lock.unlock(); | |
937 | + list.lock.unlock(); | |
1152 | 938 | } |
1153 | 939 | } |
1154 | 940 | |
1155 | - public void add(int index, E element) { | |
1156 | - final ReentrantLock lock = l.lock; | |
1157 | - lock.lock(); | |
941 | + public boolean add(Object o) { | |
942 | + list.lock.lock(); | |
1158 | 943 | try { |
1159 | - checkForComodification(); | |
1160 | - if (index<0 || index>size) | |
1161 | - throw new IndexOutOfBoundsException(); | |
1162 | - l.add(index+offset, element); | |
1163 | - expectedArray = l.getArray(); | |
1164 | - size++; | |
944 | + checkModifications(); | |
945 | + list.add(start + read.size, o); | |
946 | + read = new SubListReadData(read.size + 1, list.getData()); | |
947 | + return true; | |
1165 | 948 | } finally { |
1166 | - lock.unlock(); | |
949 | + list.lock.unlock(); | |
1167 | 950 | } |
1168 | 951 | } |
1169 | 952 | |
1170 | - public void clear() { | |
1171 | - final ReentrantLock lock = l.lock; | |
1172 | - lock.lock(); | |
953 | + public boolean addAll(Collection c) { | |
954 | + list.lock.lock(); | |
1173 | 955 | try { |
1174 | - checkForComodification(); | |
1175 | - l.removeRange(offset, offset+size); | |
1176 | - expectedArray = l.getArray(); | |
1177 | - size = 0; | |
956 | + checkModifications(); | |
957 | + int d = list.size(); | |
958 | + list.addAll(start + read.size, c); | |
959 | + read = new SubListReadData(read.size + (list.size() - d), list | |
960 | + .getData()); | |
961 | + return true; | |
1178 | 962 | } finally { |
1179 | - lock.unlock(); | |
963 | + list.lock.unlock(); | |
1180 | 964 | } |
1181 | 965 | } |
1182 | 966 | |
1183 | - public E remove(int index) { | |
1184 | - final ReentrantLock lock = l.lock; | |
1185 | - lock.lock(); | |
967 | + public void clear() { | |
968 | + list.lock.lock(); | |
1186 | 969 | try { |
1187 | - rangeCheck(index); | |
1188 | - checkForComodification(); | |
1189 | - E result = l.remove(index+offset); | |
1190 | - expectedArray = l.getArray(); | |
1191 | - size--; | |
1192 | - return result; | |
970 | + checkModifications(); | |
971 | + list.removeRange(start, read.size); | |
972 | + read = new SubListReadData(0, list.getData()); | |
1193 | 973 | } finally { |
1194 | - lock.unlock(); | |
974 | + list.lock.unlock(); | |
1195 | 975 | } |
1196 | 976 | } |
1197 | 977 | |
1198 | - public boolean remove(Object o) { | |
1199 | - int index = indexOf(o); | |
1200 | - if (index == -1) | |
1201 | - return false; | |
1202 | - remove(index); | |
1203 | - return true; | |
978 | + public boolean contains(Object o) { | |
979 | + return indexOf(o) != -1; | |
980 | + } | |
981 | + | |
982 | + public boolean containsAll(Collection c) { | |
983 | + SubListReadData b = read; | |
984 | + return CopyOnWriteArrayList.containsAll(c, b.data, start, b.size); | |
1204 | 985 | } |
1205 | 986 | |
1206 | - public Iterator<E> iterator() { | |
1207 | - final ReentrantLock lock = l.lock; | |
1208 | - lock.lock(); | |
987 | + public int indexOf(Object o) { | |
988 | + SubListReadData b = read; | |
989 | + int ind = CopyOnWriteArrayList.indexOf(o, b.data, start, b.size) | |
990 | + - start; | |
991 | + return ind < 0 ? -1 : ind; | |
992 | + } | |
993 | + | |
994 | + public boolean isEmpty() { | |
995 | + return read.size == 0; | |
996 | + } | |
997 | + | |
998 | + public Iterator iterator() { | |
999 | + return new SubListIterator(0, read); | |
1000 | + } | |
1001 | + | |
1002 | + public int lastIndexOf(Object o) { | |
1003 | + SubListReadData b = read; | |
1004 | + int ind = CopyOnWriteArrayList | |
1005 | + .lastIndexOf(o, b.data, start, b.size) | |
1006 | + - start; | |
1007 | + return ind < 0 ? -1 : ind; | |
1008 | + } | |
1009 | + | |
1010 | + public ListIterator listIterator() { | |
1011 | + return new SubListIterator(0, read); | |
1012 | + } | |
1013 | + | |
1014 | + public boolean remove(Object o) { | |
1015 | + list.lock.lock(); | |
1209 | 1016 | try { |
1210 | - checkForComodification(); | |
1211 | - return new COWSubListIterator<E>(l, 0, offset, size); | |
1017 | + checkModifications(); | |
1018 | + int i = indexOf(o); | |
1019 | + if (i == -1) { | |
1020 | + return false; | |
1021 | + } | |
1022 | + boolean result = list.remove(i + start) != null; | |
1023 | + if (result) { | |
1024 | + read = new SubListReadData(read.size - 1, list.getData()); | |
1025 | + } | |
1026 | + return result; | |
1212 | 1027 | } finally { |
1213 | - lock.unlock(); | |
1028 | + list.lock.unlock(); | |
1214 | 1029 | } |
1215 | 1030 | } |
1216 | 1031 | |
1217 | - public ListIterator<E> listIterator(final int index) { | |
1218 | - final ReentrantLock lock = l.lock; | |
1219 | - lock.lock(); | |
1032 | + public boolean removeAll(Collection c) { | |
1033 | + list.lock.lock(); | |
1220 | 1034 | try { |
1221 | - checkForComodification(); | |
1222 | - if (index<0 || index>size) | |
1223 | - throw new IndexOutOfBoundsException("Index: "+index+ | |
1224 | - ", Size: "+size); | |
1225 | - return new COWSubListIterator<E>(l, index, offset, size); | |
1035 | + checkModifications(); | |
1036 | + int removed = list.removeAll(c, start, read.size); | |
1037 | + if (removed > 0) { | |
1038 | + read = new SubListReadData(read.size - removed, list | |
1039 | + .getData()); | |
1040 | + return true; | |
1041 | + } | |
1226 | 1042 | } finally { |
1227 | - lock.unlock(); | |
1043 | + list.lock.unlock(); | |
1228 | 1044 | } |
1045 | + return false; | |
1229 | 1046 | } |
1230 | 1047 | |
1231 | - public List<E> subList(int fromIndex, int toIndex) { | |
1232 | - final ReentrantLock lock = l.lock; | |
1233 | - lock.lock(); | |
1048 | + public boolean retainAll(Collection c) { | |
1049 | + list.lock.lock(); | |
1234 | 1050 | try { |
1235 | - checkForComodification(); | |
1236 | - if (fromIndex<0 || toIndex>size) | |
1237 | - throw new IndexOutOfBoundsException(); | |
1238 | - return new COWSubList<E>(l, fromIndex + offset, | |
1239 | - toIndex + offset); | |
1051 | + checkModifications(); | |
1052 | + int removed = list.retainAll(c, start, read.size); | |
1053 | + if (removed > 0) { | |
1054 | + read = new SubListReadData(read.size - removed, list | |
1055 | + .getData()); | |
1056 | + return true; | |
1057 | + } | |
1058 | + return false; | |
1240 | 1059 | } finally { |
1241 | - lock.unlock(); | |
1060 | + list.lock.unlock(); | |
1242 | 1061 | } |
1243 | 1062 | } |
1244 | 1063 | |
1245 | - } | |
1246 | - | |
1247 | - | |
1248 | - private static class COWSubListIterator<E> implements ListIterator<E> { | |
1249 | - private final ListIterator<E> i; | |
1250 | - private final int index; | |
1251 | - private final int offset; | |
1252 | - private final int size; | |
1253 | - | |
1254 | - COWSubListIterator(List<E> l, int index, int offset, | |
1255 | - int size) { | |
1256 | - this.index = index; | |
1257 | - this.offset = offset; | |
1258 | - this.size = size; | |
1259 | - i = l.listIterator(index+offset); | |
1064 | + public List subList(int fromIndex, int toIndex) { | |
1065 | + return new SubList(list, start + fromIndex, start + toIndex); | |
1260 | 1066 | } |
1261 | 1067 | |
1262 | - public boolean hasNext() { | |
1263 | - return nextIndex() < size; | |
1068 | + public Object[] toArray() { | |
1069 | + SubListReadData r = read; | |
1070 | + return CopyOnWriteArrayList.toArray(r.data, start, r.size); | |
1264 | 1071 | } |
1265 | 1072 | |
1266 | - public E next() { | |
1267 | - if (hasNext()) | |
1268 | - return i.next(); | |
1269 | - else | |
1270 | - throw new NoSuchElementException(); | |
1073 | + public Object[] toArray(Object[] a) { | |
1074 | + SubListReadData r = read; | |
1075 | + return CopyOnWriteArrayList.toArray(a, r.data, start, r.size); | |
1271 | 1076 | } |
1272 | 1077 | |
1273 | - public boolean hasPrevious() { | |
1274 | - return previousIndex() >= 0; | |
1078 | + /** | |
1079 | + * @see java.util.List#addAll(int, java.util.Collection) | |
1080 | + */ | |
1081 | + public boolean addAll(int index, Collection collection) { | |
1082 | + list.lock.lock(); | |
1083 | + try { | |
1084 | + checkIndexInclusive(index, read.size); | |
1085 | + checkModifications(); | |
1086 | + int d = list.size(); | |
1087 | + boolean rt = list.addAll(index + start, collection); | |
1088 | + read = new SubListReadData(read.size + list.size() - d, list | |
1089 | + .getData()); | |
1090 | + return rt; | |
1091 | + } finally { | |
1092 | + list.lock.unlock(); | |
1093 | + } | |
1275 | 1094 | } |
1276 | 1095 | |
1277 | - public E previous() { | |
1278 | - if (hasPrevious()) | |
1279 | - return i.previous(); | |
1280 | - else | |
1281 | - throw new NoSuchElementException(); | |
1282 | - } | |
1096 | + /** | |
1097 | + * Implementation of <code>ListIterator</code> for the | |
1098 | + * <code>SubList</code> | |
1099 | + * gets a snapshot of the sublist, | |
1100 | + * never throws ConcurrentModificationException | |
1101 | + */ | |
1102 | + private class SubListIterator extends ListIteratorImpl { | |
1103 | + private final SubListReadData dataR; | |
1104 | + | |
1105 | + /** | |
1106 | + * Constructs an iterator starting with the given index | |
1107 | + * | |
1108 | + * @param index index of the first element to iterate. | |
1109 | + */ | |
1110 | + private SubListIterator(int index, SubListReadData d) { | |
1111 | + super(d.data, index + start); | |
1112 | + this.dataR = d; | |
1113 | + } | |
1283 | 1114 | |
1284 | - public int nextIndex() { | |
1285 | - return i.nextIndex() - offset; | |
1286 | - } | |
1115 | + /** | |
1116 | + * @see java.util.ListIterator#nextIndex() | |
1117 | + */ | |
1118 | + public int nextIndex() { | |
1119 | + return super.nextIndex() - start; | |
1120 | + } | |
1287 | 1121 | |
1288 | - public int previousIndex() { | |
1289 | - return i.previousIndex() - offset; | |
1290 | - } | |
1122 | + /** | |
1123 | + * @see java.util.ListIterator#previousIndex() | |
1124 | + */ | |
1125 | + public int previousIndex() { | |
1126 | + return super.previousIndex() - start; | |
1127 | + } | |
1291 | 1128 | |
1292 | - public void remove() { | |
1293 | - throw new UnsupportedOperationException(); | |
1294 | - } | |
1129 | + /** | |
1130 | + * @see java.util.Iterator#hasNext() | |
1131 | + */ | |
1132 | + public boolean hasNext() { | |
1133 | + return nextIndex() < dataR.size; | |
1134 | + } | |
1295 | 1135 | |
1296 | - public void set(E e) { | |
1297 | - throw new UnsupportedOperationException(); | |
1136 | + /** | |
1137 | + * @see java.util.ListIterator#hasPrevious() | |
1138 | + */ | |
1139 | + public boolean hasPrevious() { | |
1140 | + return previousIndex() > -1; | |
1141 | + } | |
1298 | 1142 | } |
1299 | 1143 | |
1300 | - public void add(E e) { | |
1301 | - throw new UnsupportedOperationException(); | |
1302 | - } | |
1303 | 1144 | } |
1304 | 1145 | |
1305 | - // Support for resetting lock while deserializing | |
1306 | - private static final Unsafe unsafe = Unsafe.getUnsafe(); | |
1307 | - private static final long lockOffset; | |
1308 | - static { | |
1309 | - try { | |
1310 | - lockOffset = unsafe.objectFieldOffset | |
1311 | - (CopyOnWriteArrayList.class.getDeclaredField("lock")); | |
1312 | - } catch (Exception ex) { throw new Error(ex); } | |
1146 | + //serialization support | |
1147 | + /** | |
1148 | + * Writes the object state to the ObjectOutputStream. | |
1149 | + * | |
1150 | + * @param oos ObjectOutputStream to write object to. | |
1151 | + * @throws IOException if an I/O error occur. | |
1152 | + */ | |
1153 | + private void writeObject(ObjectOutputStream oos) throws IOException { | |
1154 | + E[] back = getData(); | |
1155 | + int size = back.length; | |
1156 | + oos.defaultWriteObject(); | |
1157 | + oos.writeInt(size); | |
1158 | + for (int i = 0; i < size; i++) { | |
1159 | + oos.writeObject(back[i]); | |
1160 | + } | |
1313 | 1161 | } |
1314 | - private void resetLock() { | |
1315 | - unsafe.putObjectVolatile(this, lockOffset, new ReentrantLock()); | |
1162 | + | |
1163 | + /** | |
1164 | + * Reads the object state from the ObjectOutputStream. | |
1165 | + * | |
1166 | + * @param ois ObjectInputStream to read object from. | |
1167 | + * @throws IOException if an I/O error occur. | |
1168 | + */ | |
1169 | + private void readObject(ObjectInputStream ois) throws IOException, | |
1170 | + ClassNotFoundException { | |
1171 | + ois.defaultReadObject(); | |
1172 | + int length = ois.readInt(); | |
1173 | + if (length == 0) { | |
1174 | + setData(newElementArray(0)); | |
1175 | + } else { | |
1176 | + E[] back = newElementArray(length); | |
1177 | + for (int i = 0; i < back.length; i++) { | |
1178 | + back[i] = (E) ois.readObject(); | |
1179 | + } | |
1180 | + setData(back); | |
1181 | + } | |
1316 | 1182 | } |
1183 | + | |
1317 | 1184 | } |
@@ -109,12 +109,27 @@ public class Zygote { | ||
109 | 109 | * dimension having a length of 3 and representing |
110 | 110 | * (resource, rlim_cur, rlim_max). These are set via the posix |
111 | 111 | * setrlimit(2) call. |
112 | + * @param permittedCapabilities argument for setcap() | |
113 | + * @param effectiveCapabilities argument for setcap() | |
112 | 114 | * |
113 | 115 | * @return 0 if this is the child, pid of the child |
114 | 116 | * if this is the parent, or -1 on error. |
117 | + * | |
118 | + * @hide | |
119 | + */ | |
120 | + native public static int forkSystemServer(int uid, int gid, | |
121 | + int[] gids, int debugFlags, int[][] rlimits, | |
122 | + long permittedCapabilities, long effectiveCapabilities); | |
123 | + | |
124 | + /* | |
125 | + * For bug 3176774, we needed to update forkSystemServer() after | |
126 | + * the API was locked down. To avoid going out of sync with the | |
127 | + * API description file, we provide a dummy function here. | |
115 | 128 | */ |
116 | - native public static int forkSystemServer(int uid, int gid, | |
117 | - int[] gids, int debugFlags, int[][] rlimits); | |
129 | + public static int forkSystemServer(int uid, int gid, | |
130 | + int[] gids, int debugFlags, int[][] rlimits) { | |
131 | + throw new UnsupportedOperationException(); | |
132 | + } | |
118 | 133 | |
119 | 134 | /** |
120 | 135 | * Special method to start the system server process. |
@@ -1999,10 +1999,13 @@ public class ThreadTest extends junit.framework.TestCase { | ||
1999 | 1999 | |
2000 | 2000 | while (!sem.hasQueuedThreads()){} |
2001 | 2001 | |
2002 | + long start = System.currentTimeMillis(); | |
2003 | + while(start + 1000 > System.currentTimeMillis()) {} | |
2002 | 2004 | assertEquals(Thread.State.WAITING, th.getState()); |
2005 | + | |
2003 | 2006 | synchronized (lock) { |
2004 | 2007 | sem.release(); |
2005 | - long start = System.currentTimeMillis(); | |
2008 | + start = System.currentTimeMillis(); | |
2006 | 2009 | while(start + 1000 > System.currentTimeMillis()) {} |
2007 | 2010 | assertEquals(Thread.State.BLOCKED, th.getState()); |
2008 | 2011 | } |
@@ -40,23 +40,14 @@ import java.security.cert.Certificate; | ||
40 | 40 | import org.apache.harmony.security.tests.support.TestCertUtils; |
41 | 41 | |
42 | 42 | import junit.framework.TestCase; |
43 | + | |
43 | 44 | @TestTargetClass(CodeSource.class) |
44 | 45 | /** |
45 | 46 | * Unit test for CodeSource. |
46 | - * | |
47 | + * | |
47 | 48 | */ |
48 | 49 | |
49 | 50 | public class CodeSourceTest extends TestCase { |
50 | - /** | |
51 | - * | |
52 | - * Entry point for standalone runs. | |
53 | - * | |
54 | - * @param args command line arguments | |
55 | - */ | |
56 | - public static void main(String[] args) throws Exception { | |
57 | - junit.textui.TestRunner.run(CodeSourceTest.class); | |
58 | - } | |
59 | - | |
60 | 51 | private java.security.cert.Certificate[] chain = null; |
61 | 52 | |
62 | 53 | /* Below are various URLs used during the testing */ |
@@ -83,7 +74,7 @@ public class CodeSourceTest extends TestCase { | ||
83 | 74 | private static URL urlFileDirStar; |
84 | 75 | |
85 | 76 | private static URL urlRef1, urlRef2; |
86 | - | |
77 | + | |
87 | 78 | private boolean init = false; |
88 | 79 | |
89 | 80 | private void init() { |
@@ -92,28 +83,28 @@ public class CodeSourceTest extends TestCase { | ||
92 | 83 | String siteName = "www.intel.com"; |
93 | 84 | InetAddress addr = InetAddress.getByName(siteName); |
94 | 85 | String siteIP = addr.getHostAddress(); |
95 | - | |
86 | + | |
96 | 87 | urlSite = new URL("http://"+siteName+""); |
97 | 88 | urlDir = new URL("http://"+siteName+"/drl_test"); |
98 | 89 | urlDirOtherSite = new URL("http://www.any-other-site-which-is-not-siteName.com/drl_test"); |
99 | - | |
90 | + | |
100 | 91 | urlDir_port80 = new URL("http://"+siteName+":80/drl_test"); |
101 | 92 | urlDir_port81 = new URL("http://"+siteName+":81/drl_test"); |
102 | 93 | urlDirWithSlash = new URL(urlDir + "/"); |
103 | - | |
94 | + | |
104 | 95 | //urlDirFtp = new URL("ftp://www.intel.com/drl_test"); |
105 | 96 | urlDir_FileProtocol = new URL("file://"+siteName+"/drl_test"); |
106 | - | |
97 | + | |
107 | 98 | urlDirIP = new URL("http://"+siteIP+"/drl_test"); |
108 | - | |
99 | + | |
109 | 100 | urlFile = new URL("http://"+siteName+"/drl_test/empty.jar"); |
110 | 101 | urlFileWithAdditionalDirs = new URL( |
111 | 102 | "http://"+siteName+"/drl_test/what/ever/here/empty.jar"); |
112 | - | |
103 | + | |
113 | 104 | urlFileDirMinus = new URL("http://"+siteName+"/drl_test/-"); |
114 | 105 | urlFileDirStar = new URL("http://"+siteName+"/drl_test/*"); |
115 | 106 | urlFileDirOtherDir = new URL("http://"+siteName+"/_test_drl_/*"); |
116 | - | |
107 | + | |
117 | 108 | urlRef1 = new URL("http://"+siteName+"/drl_test/index.html#ref1"); |
118 | 109 | urlRef2 = new URL("http://"+siteName+"/drl_test/index.html#ref2"); |
119 | 110 | } catch (MalformedURLException ex) { |
@@ -134,7 +125,7 @@ public class CodeSourceTest extends TestCase { | ||
134 | 125 | |
135 | 126 | /** |
136 | 127 | * Tests hashCode().<br> |
137 | - * javadoc says nothing, so test DRL-specific implementation. | |
128 | + * javadoc says nothing, so test DRL-specific implementation. | |
138 | 129 | */ |
139 | 130 | @TestTargetNew( |
140 | 131 | level = TestLevel.COMPLETE, |
@@ -143,7 +134,7 @@ public class CodeSourceTest extends TestCase { | ||
143 | 134 | args = {} |
144 | 135 | ) |
145 | 136 | public void testHashCode() { |
146 | - // when nothing is specified, then hashCode obviously must be 0. | |
137 | + // when nothing is specified, then hashCode obviously must be 0. | |
147 | 138 | assertTrue(new CodeSource(null, (Certificate[]) null).hashCode() == 0); |
148 | 139 | // only URL.hashCode is taken into account... |
149 | 140 | assertTrue(new CodeSource(urlSite, (Certificate[]) null).hashCode() == urlSite |
@@ -217,7 +208,7 @@ public class CodeSourceTest extends TestCase { | ||
217 | 208 | |
218 | 209 | /** |
219 | 210 | * Test for equals(Object)<br> |
220 | - * The signer certificate chain must contain the same set of certificates, but | |
211 | + * The signer certificate chain must contain the same set of certificates, but | |
221 | 212 | * the order of the certificates is not taken into account. |
222 | 213 | */ |
223 | 214 | @TestTargetNew( |
@@ -238,7 +229,7 @@ public class CodeSourceTest extends TestCase { | ||
238 | 229 | |
239 | 230 | /** |
240 | 231 | * Test for equals(Object)<br> |
241 | - * Checks that both 'null' and not-null URLs are taken into account - properly. | |
232 | + * Checks that both 'null' and not-null URLs are taken into account - properly. | |
242 | 233 | */ |
243 | 234 | @TestTargetNew( |
244 | 235 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -277,7 +268,7 @@ public class CodeSourceTest extends TestCase { | ||
277 | 268 | } |
278 | 269 | |
279 | 270 | /** |
280 | - * Tests whether the getCertificates() returns certificates obtained from | |
271 | + * Tests whether the getCertificates() returns certificates obtained from | |
281 | 272 | * the signers. |
282 | 273 | */ |
283 | 274 | @TestTargetNew( |
@@ -295,19 +286,19 @@ public class CodeSourceTest extends TestCase { | ||
295 | 286 | CodeSigner[] signers = { new CodeSigner(cpath, null) }; |
296 | 287 | CodeSource cs = new CodeSource(null, signers); |
297 | 288 | Certificate[] got = cs.getCertificates(); |
298 | - // The set of certificates must be exactly the same, | |
289 | + // The set of certificates must be exactly the same, | |
299 | 290 | // but the order is not specified |
300 | 291 | assertTrue(presented(certs, got)); |
301 | 292 | assertTrue(presented(got, certs)); |
302 | 293 | } |
303 | 294 | |
304 | 295 | /** |
305 | - * Checks whether two arrays of certificates represent the same same set of | |
296 | + * Checks whether two arrays of certificates represent the same same set of | |
306 | 297 | * certificates - in the same order. |
307 | - * @param one first array | |
298 | + * @param one first array | |
308 | 299 | * @param two second array |
309 | - * @return <code>true</code> if both arrays represent the same set of | |
310 | - * certificates, | |
300 | + * @return <code>true</code> if both arrays represent the same set of | |
301 | + * certificates, | |
311 | 302 | * <code>false</code> otherwise. |
312 | 303 | */ |
313 | 304 | private static boolean checkEqual(java.security.cert.Certificate[] one, |
@@ -342,10 +333,10 @@ public class CodeSourceTest extends TestCase { | ||
342 | 333 | /** |
343 | 334 | * Performs a test whether the <code>what</code> certificates are all |
344 | 335 | * presented in <code>where</code> certificates. |
345 | - * | |
336 | + * | |
346 | 337 | * @param what - first array of Certificates |
347 | 338 | * @param where - second array of Certificates |
348 | - * @return <code>true</code> if each and every certificate from 'what' | |
339 | + * @return <code>true</code> if each and every certificate from 'what' | |
349 | 340 | * (including null) is presented in 'where' <code>false</code> otherwise |
350 | 341 | */ |
351 | 342 | private static boolean presented(Certificate[] what, Certificate[] where) { |
@@ -413,7 +404,7 @@ public class CodeSourceTest extends TestCase { | ||
413 | 404 | assertTrue(found); |
414 | 405 | } |
415 | 406 | } |
416 | - | |
407 | + | |
417 | 408 | /** |
418 | 409 | * Tests CodeSource.getCodeSigners() for null. |
419 | 410 | */ |
@@ -424,7 +415,7 @@ public class CodeSourceTest extends TestCase { | ||
424 | 415 | args = {} |
425 | 416 | ) |
426 | 417 | public void testGetCoderSignersNull() throws Exception{ |
427 | - assertNull(new CodeSource(new URL("http://url"), (Certificate[])null).getCodeSigners()); //$NON-NLS-1$ | |
418 | + assertNull(new CodeSource(new URL("http://url"), (Certificate[])null).getCodeSigners()); | |
428 | 419 | } |
429 | 420 | |
430 | 421 | /** |
@@ -453,7 +444,7 @@ public class CodeSourceTest extends TestCase { | ||
453 | 444 | args = {} |
454 | 445 | ) |
455 | 446 | public void testToString() { |
456 | - // Javadoc keeps silence about String's format, | |
447 | + // Javadoc keeps silence about String's format, | |
457 | 448 | // just make sure it can be invoked. |
458 | 449 | new CodeSource(urlSite, chain).toString(); |
459 | 450 | new CodeSource(null, chain).toString(); |
@@ -462,9 +453,9 @@ public class CodeSourceTest extends TestCase { | ||
462 | 453 | |
463 | 454 | /** |
464 | 455 | * Tests whether we are running with the 1.5 features.<br> |
465 | - * The test is preformed by looking for (via reflection) the CodeSource's | |
456 | + * The test is preformed by looking for (via reflection) the CodeSource's | |
466 | 457 | * constructor {@link CodeSource#CodeSource(URL, CodeSigner[])}. |
467 | - * @return <code>true</code> if 1.5 feature is presented, <code>false</code> | |
458 | + * @return <code>true</code> if 1.5 feature is presented, <code>false</code> | |
468 | 459 | * otherwise. |
469 | 460 | */ |
470 | 461 | private static boolean has_15_features() { |
@@ -473,7 +464,7 @@ public class CodeSourceTest extends TestCase { | ||
473 | 464 | try { |
474 | 465 | klass.getConstructor(ctorArgs); |
475 | 466 | } catch (NoSuchMethodException ex) { |
476 | - // NoSuchMethod == Not RI.v1.5 and not DRL | |
467 | + // NoSuchMethod == Not RI.v1.5 and not DRL | |
477 | 468 | return false; |
478 | 469 | } |
479 | 470 | return true; |
@@ -512,9 +503,6 @@ public class CodeSourceTest extends TestCase { | ||
512 | 503 | assertFalse(thizCS.implies(thatCS)); |
513 | 504 | } |
514 | 505 | |
515 | - /** | |
516 | - * If this object's location equals codesource's location, then return true. | |
517 | - */ | |
518 | 506 | @TestTargetNew( |
519 | 507 | level = TestLevel.PARTIAL_COMPLETE, |
520 | 508 | notes = "", |
@@ -530,10 +518,6 @@ public class CodeSourceTest extends TestCase { | ||
530 | 518 | |
531 | 519 | } |
532 | 520 | |
533 | - /** | |
534 | - * This object's protocol (getLocation().getProtocol()) must be equal to | |
535 | - * codesource's protocol. | |
536 | - */ | |
537 | 521 | /* |
538 | 522 | * FIXME |
539 | 523 | * commented out for temporary, as there is no FTP:// protocol supported yet. |
@@ -559,11 +543,6 @@ public class CodeSourceTest extends TestCase { | ||
559 | 543 | assertFalse(thatCS.implies(thizCS)); |
560 | 544 | } |
561 | 545 | |
562 | - /** | |
563 | - * If this object's host (getLocation().getHost()) is not null, then the | |
564 | - * SocketPermission constructed with this object's host must imply the | |
565 | - * SocketPermission constructed with codesource's host. | |
566 | - */ | |
567 | 546 | @TestTargetNew( |
568 | 547 | level = TestLevel.PARTIAL_COMPLETE, |
569 | 548 | notes = "", |
@@ -577,7 +556,7 @@ public class CodeSourceTest extends TestCase { | ||
577 | 556 | assertTrue(thizCS.implies(thatCS)); |
578 | 557 | assertTrue(thatCS.implies(thizCS)); |
579 | 558 | |
580 | - // | |
559 | + // | |
581 | 560 | // Check for another site - force to create SocketPermission |
582 | 561 | // |
583 | 562 | thatCS = new CodeSource(urlDirOtherSite, (Certificate[]) null); |
@@ -595,10 +574,6 @@ public class CodeSourceTest extends TestCase { | ||
595 | 574 | assertFalse(thatCS.implies(thizCS)); |
596 | 575 | } |
597 | 576 | |
598 | - /** | |
599 | - * If this object's port (getLocation().getPort()) is not equal to -1 (that | |
600 | - * is, if a port is specified), it must equal codesource's port. | |
601 | - */ | |
602 | 577 | @TestTargetNew( |
603 | 578 | level = TestLevel.PARTIAL_COMPLETE, |
604 | 579 | notes = "", |
@@ -626,10 +601,6 @@ public class CodeSourceTest extends TestCase { | ||
626 | 601 | assertFalse(thizCS.implies(thatCS)); |
627 | 602 | } |
628 | 603 | |
629 | - /** | |
630 | - * If this object's file (getLocation().getFile()) doesn't equal | |
631 | - * codesource's file, then the following checks are made: ... | |
632 | - */ | |
633 | 604 | @TestTargetNew( |
634 | 605 | level = TestLevel.PARTIAL_COMPLETE, |
635 | 606 | notes = "", |
@@ -642,10 +613,6 @@ public class CodeSourceTest extends TestCase { | ||
642 | 613 | assertTrue(thizCS.implies(thatCS)); |
643 | 614 | } |
644 | 615 | |
645 | - /** | |
646 | - * ... If this object's file ends with "/-", then codesource's file must | |
647 | - * start with this object's file (exclusive the trailing "-"). | |
648 | - */ | |
649 | 616 | @TestTargetNew( |
650 | 617 | level = TestLevel.PARTIAL_COMPLETE, |
651 | 618 | notes = "", |
@@ -664,11 +631,6 @@ public class CodeSourceTest extends TestCase { | ||
664 | 631 | assertFalse(thiz.implies(that)); |
665 | 632 | } |
666 | 633 | |
667 | - /** | |
668 | - * ... If this object's file ends with a "/*", then codesource's file must | |
669 | - * start with this object's file and must not have any further "/" | |
670 | - * separators. | |
671 | - */ | |
672 | 634 | @TestTargetNew( |
673 | 635 | level = TestLevel.PARTIAL_COMPLETE, |
674 | 636 | notes = "", |
@@ -690,10 +652,6 @@ public class CodeSourceTest extends TestCase { | ||
690 | 652 | assertFalse(thiz.implies(that)); |
691 | 653 | } |
692 | 654 | |
693 | - /** | |
694 | - * ... If this object's file doesn't end with a "/", then codesource's file | |
695 | - * must match this object's file with a '/' appended. | |
696 | - */ | |
697 | 655 | @TestTargetNew( |
698 | 656 | level = TestLevel.PARTIAL_COMPLETE, |
699 | 657 | notes = "", |
@@ -708,10 +666,6 @@ public class CodeSourceTest extends TestCase { | ||
708 | 666 | assertFalse(thatCS.implies(thizCS)); |
709 | 667 | } |
710 | 668 | |
711 | - /** | |
712 | - * If this object's reference (getLocation().getRef()) is not null, it must | |
713 | - * equal codesource's reference. | |
714 | - */ | |
715 | 669 | @TestTargetNew( |
716 | 670 | level = TestLevel.PARTIAL_COMPLETE, |
717 | 671 | notes = "", |
@@ -754,7 +708,7 @@ public class CodeSourceTest extends TestCase { | ||
754 | 708 | |
755 | 709 | // |
756 | 710 | that = new CodeSource(urlSite, (Certificate[]) null); |
757 | - // 'thiz' has set of certs, while 'that' has no certs. URL-s are the | |
711 | + // 'thiz' has set of certs, while 'that' has no certs. URL-s are the | |
758 | 712 | // same. |
759 | 713 | assertFalse(thiz.implies(that)); |
760 | 714 | assertTrue(that.implies(thiz)); |
@@ -762,8 +716,8 @@ public class CodeSourceTest extends TestCase { | ||
762 | 716 | |
763 | 717 | /** |
764 | 718 | * Testing with special URLs like 'localhost', 'file://' scheme ... |
765 | - * These special URLs have a special processing in implies(), | |
766 | - * so they need to be covered and performance need to be checked | |
719 | + * These special URLs have a special processing in implies(), | |
720 | + * so they need to be covered and performance need to be checked | |
767 | 721 | */ |
768 | 722 | @TestTargetNew( |
769 | 723 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -783,8 +737,8 @@ public class CodeSourceTest extends TestCase { | ||
783 | 737 | |
784 | 738 | /** |
785 | 739 | * Testing with special URLs like 'localhost', 'file://' scheme ... |
786 | - * These special URLs have a special processing in implies(), | |
787 | - * so they need to be covered and performance need to be checked | |
740 | + * These special URLs have a special processing in implies(), | |
741 | + * so they need to be covered and performance need to be checked | |
788 | 742 | */ |
789 | 743 | @TestTargetNew( |
790 | 744 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -1,65 +1,174 @@ | ||
1 | -// Copyright 2009 Google Inc. All Rights Reserved. | |
1 | +/* | |
2 | + * Copyright (C) 2011 The Android Open Source Project | |
3 | + * | |
4 | + * Licensed under the Apache License, Version 2.0 (the "License"); | |
5 | + * you may not use this file except in compliance with the License. | |
6 | + * 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 | + */ | |
2 | 16 | |
3 | 17 | package org.bouncycastle.jce.provider; |
4 | 18 | |
19 | +import java.io.ByteArrayInputStream; | |
20 | +import java.io.ByteArrayOutputStream; | |
21 | +import java.security.cert.CertificateFactory; | |
22 | +import java.security.cert.X509Certificate; | |
23 | +import javax.security.auth.x500.X500Principal; | |
5 | 24 | import junit.framework.TestCase; |
6 | -import org.apache.harmony.security.provider.cert.X509CertImpl; | |
7 | -import org.apache.harmony.security.provider.cert.X509CertPathImpl; | |
8 | -import org.bouncycastle.asn1.x509.X509CertificateStructure; | |
9 | -import org.bouncycastle.asn1.ASN1Sequence; | |
10 | -import org.bouncycastle.asn1.ASN1InputStream; | |
11 | 25 | |
12 | 26 | import java.io.IOException; |
13 | -import java.util.Arrays; | |
14 | -import java.util.Set; | |
15 | -import java.util.HashSet; | |
16 | -import java.security.cert.CertificateException; | |
17 | -import java.security.cert.TrustAnchor; | |
18 | -import java.security.cert.CertPathValidatorException; | |
19 | -import java.security.KeyStoreException; | |
20 | -import java.security.InvalidAlgorithmParameterException; | |
27 | +import java.io.ObjectInputStream; | |
28 | +import java.io.ObjectOutputStream; | |
29 | +import static junit.framework.Assert.assertEquals; | |
30 | +import static junit.framework.Assert.fail; | |
31 | +import junit.framework.AssertionFailedError; | |
21 | 32 | |
22 | 33 | /** |
23 | 34 | * Verify the behavior of PKIXCertPathValidatorSpi. |
24 | 35 | */ |
25 | 36 | public class PKIXCertPathValidatorSpiTest extends TestCase { |
26 | 37 | |
38 | + public void testSerialization() { | |
39 | + String expected = "aced0005737200266a617661782e73656375726974792e617574682e7" | |
40 | + + "83530302e583530305072696e636970616cf90dff3c88b877c703000078707572" | |
41 | + + "00025b42acf317f8060854e002000078700000006a30683117301506035504031" | |
42 | + + "30e7777772e676f6f676c652e636f6d31133011060355040a130a476f6f676c65" | |
43 | + + "20496e63311630140603550407130d4d6f756e7461696e2056696577311330110" | |
44 | + + "603550408130a43616c69666f726e6961310b300906035504061302555378"; | |
45 | + X500Principal actual = new X500Principal("C=US, " | |
46 | + + "ST=California, " | |
47 | + + "L=Mountain View, " | |
48 | + + "O=Google Inc, " | |
49 | + + "CN=www.google.com"); | |
50 | + new SerializableTester<X500Principal>(actual, expected).test(); | |
51 | + } | |
52 | + | |
27 | 53 | /** |
28 | - * A chain of 3 ASN1-encoded certificates for https://service.sprint.com. | |
29 | - * The certificate subjects are "service.sprint.com", "Entrust Certification | |
30 | - * Authority - L1B", and "Entrust.net Certification Authority (2048)". The | |
31 | - * last certificate uses UTF8 encoding for its X509 name. | |
54 | + * ASN1-encoded trusted certificate #946059622 for | |
55 | + * Entrust.net. This certificate uses the T61String (aka | |
56 | + * TeletexString or TELETEXSTRING) encoding for one | |
57 | + * organizationalUnitNames: | |
58 | + * | |
59 | + * "www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)" | |
32 | 60 | */ |
33 | - private final byte[][] serviceSprintComCertChain = new byte[][] { | |
34 | - new byte[] { 48, -126, 6, 89, 48, -126, 5, 65, -96, 3, 2, 1, 2, 2, 4, 72, 13, 115, -81, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 5, 5, 0, 48, -126, 1, 52, 49, 11, 48, 9, 6, 3, 85, 4, 6, 19, 2, 85, 83, 49, 22, 48, 20, 6, 3, 85, 4, 10, 19, 13, 69, 110, 116, 114, 117, 115, 116, 44, 32, 73, 110, 99, 46, 49, 56, 48, 54, 6, 3, 85, 4, 11, 19, 47, 65, 78, 68, 32, 65, 68, 68, 73, 84, 73, 79, 78, 65, 76, 32, 84, 69, 82, 77, 83, 32, 71, 79, 86, 69, 82, 78, 73, 78, 71, 32, 85, 83, 69, 32, 65, 78, 68, 32, 82, 69, 76, 73, 65, 78, 67, 69, 49, 71, 48, 69, 6, 3, 85, 4, 11, 19, 62, 67, 80, 83, 32, 67, 79, 78, 84, 65, 73, 78, 83, 32, 73, 77, 80, 79, 82, 84, 65, 78, 84, 32, 76, 73, 77, 73, 84, 65, 84, 73, 79, 78, 83, 32, 79, 70, 32, 87, 65, 82, 82, 65, 78, 84, 73, 69, 83, 32, 65, 78, 68, 32, 76, 73, 65, 66, 73, 76, 73, 84, 89, 49, 57, 48, 55, 6, 3, 85, 4, 11, 19, 48, 119, 119, 119, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 67, 80, 83, 32, 105, 115, 32, 105, 110, 99, 111, 114, 112, 111, 114, 97, 116, 101, 100, 32, 98, 121, 32, 114, 101, 102, 101, 114, 101, 110, 99, 101, 49, 31, 48, 29, 6, 3, 85, 4, 11, 19, 22, 40, 99, 41, 32, 50, 48, 48, 56, 32, 69, 110, 116, 114, 117, 115, 116, 44, 32, 73, 110, 99, 46, 49, 46, 48, 44, 6, 3, 85, 4, 3, 19, 37, 69, 110, 116, 114, 117, 115, 116, 32, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 32, 65, 117, 116, 104, 111, 114, 105, 116, 121, 32, 45, 32, 76, 49, 66, 48, 30, 23, 13, 48, 57, 48, 52, 50, 57, 49, 53, 50, 54, 53, 57, 90, 23, 13, 49, 49, 48, 53, 48, 53, 49, 53, 53, 54, 53, 55, 90, 48, 120, 49, 11, 48, 9, 6, 3, 85, 4, 6, 19, 2, 85, 83, 49, 15, 48, 13, 6, 3, 85, 4, 8, 19, 6, 75, 65, 78, 83, 65, 83, 49, 22, 48, 20, 6, 3, 85, 4, 7, 19, 13, 79, 118, 101, 114, 108, 97, 110, 100, 32, 80, 97, 114, 107, 49, 15, 48, 13, 6, 3, 85, 4, 10, 19, 6, 83, 112, 114, 105, 110, 116, 49, 18, 48, 16, 6, 3, 85, 4, 11, 19, 9, 100, 97, 115, 110, 109, 112, 48, 52, 98, 49, 27, 48, 25, 6, 3, 85, 4, 3, 19, 18, 115, 101, 114, 118, 105, 99, 101, 46, 115, 112, 114, 105, 110, 116, 46, 99, 111, 109, 48, -127, -97, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 1, 5, 0, 3, -127, -115, 0, 48, -127, -119, 2, -127, -127, 0, -80, 99, 109, 108, 94, -41, -78, 88, 56, -97, 33, -23, 65, -74, -118, 0, 1, 119, 126, 122, -59, -83, -25, -16, -75, -87, 100, 46, 37, -98, 65, -104, 54, -87, 56, -81, 96, -38, -4, -78, 11, 101, -29, 70, -13, -110, -76, -125, -106, -35, 41, 83, 71, 56, 6, 67, -8, 82, -58, -81, -113, 90, 91, 79, 74, -38, 34, 28, 39, -37, -12, 54, 87, 61, 48, 33, -16, 10, 112, -40, -37, -15, 59, -72, 112, 96, 85, 109, 123, -122, 58, 18, 95, 56, -81, 49, 43, -39, 99, 69, -28, -81, -106, -64, 8, -62, 40, -92, 95, -109, -122, 94, 53, -13, -33, 88, -104, 3, -77, -30, -27, 23, 92, -69, 12, -23, -9, 125, 2, 3, 1, 0, 1, -93, -126, 2, -81, 48, -126, 2, -85, 48, 11, 6, 3, 85, 29, 15, 4, 4, 3, 2, 5, -96, 48, 43, 6, 3, 85, 29, 16, 4, 36, 48, 34, -128, 15, 50, 48, 48, 57, 48, 52, 50, 57, 49, 53, 50, 54, 53, 57, 90, -127, 15, 50, 48, 49, 49, 48, 53, 48, 53, 49, 53, 53, 54, 53, 55, 90, 48, 19, 6, 3, 85, 29, 37, 4, 12, 48, 10, 6, 8, 43, 6, 1, 5, 5, 7, 3, 1, 48, 51, 6, 3, 85, 29, 31, 4, 44, 48, 42, 48, 40, -96, 38, -96, 36, -122, 34, 104, 116, 116, 112, 58, 47, 47, 99, 114, 108, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 108, 101, 118, 101, 108, 49, 98, 46, 99, 114, 108, 48, 100, 6, 8, 43, 6, 1, 5, 5, 7, 1, 1, 4, 88, 48, 86, 48, 35, 6, 8, 43, 6, 1, 5, 5, 7, 48, 1, -122, 23, 104, 116, 116, 112, 58, 47, 47, 111, 99, 115, 112, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 48, 47, 6, 8, 43, 6, 1, 5, 5, 7, 48, 2, -122, 35, 104, 116, 116, 112, 58, 47, 47, 97, 105, 97, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 50, 48, 52, 56, 45, 108, 49, 98, 46, 99, 101, 114, 48, -126, 1, 87, 6, 3, 85, 29, 32, 4, -126, 1, 78, 48, -126, 1, 74, 48, -126, 1, 70, 6, 9, 42, -122, 72, -122, -10, 125, 7, 75, 2, 48, -126, 1, 55, 48, 38, 6, 8, 43, 6, 1, 5, 5, 7, 2, 1, 22, 26, 104, 116, 116, 112, 58, 47, 47, 119, 119, 119, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 99, 112, 115, 48, -126, 1, 11, 6, 8, 43, 6, 1, 5, 5, 7, 2, 2, 48, -127, -2, 26, -127, -5, 84, 104, 101, 32, 69, 110, 116, 114, 117, 115, 116, 32, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 32, 80, 114, 97, 99, 116, 105, 99, 101, 32, 83, 116, 97, 116, 101, 109, 101, 110, 116, 32, 40, 67, 80, 83, 41, 32, 97, 118, 97, 105, 108, 97, 98, 108, 101, 32, 97, 116, 32, 119, 119, 119, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 99, 112, 115, 32, 32, 105, 115, 32, 104, 101, 114, 101, 98, 121, 32, 105, 110, 99, 111, 114, 112, 111, 114, 97, 116, 101, 100, 32, 105, 110, 116, 111, 32, 121, 111, 117, 114, 32, 117, 115, 101, 32, 111, 114, 32, 114, 101, 108, 105, 97, 110, 99, 101, 32, 111, 110, 32, 116, 104, 105, 115, 32, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 46, 32, 32, 84, 104, 105, 115, 32, 67, 80, 83, 32, 99, 111, 110, 116, 97, 105, 110, 115, 32, 108, 105, 109, 105, 116, 97, 116, 105, 111, 110, 115, 32, 111, 110, 32, 119, 97, 114, 114, 97, 110, 116, 105, 101, 115, 32, 97, 110, 100, 32, 108, 105, 97, 98, 105, 108, 105, 116, 105, 101, 115, 46, 32, 67, 111, 112, 121, 114, 105, 103, 104, 116, 32, 40, 99, 41, 32, 50, 48, 48, 56, 32, 69, 110, 116, 114, 117, 115, 116, 32, 76, 105, 109, 105, 116, 101, 100, 48, 31, 6, 3, 85, 29, 35, 4, 24, 48, 22, -128, 20, -11, -14, -106, -120, 125, 13, -13, 42, -7, 78, -25, 52, -96, -67, 70, 126, 19, -42, 22, -56, 48, 29, 6, 3, 85, 29, 14, 4, 22, 4, 20, 68, 101, 26, -23, -69, -107, 32, 89, 18, 28, -123, 32, 74, -116, -33, -48, 70, -52, 68, 77, 48, 9, 6, 3, 85, 29, 19, 4, 2, 48, 0, 48, 25, 6, 9, 42, -122, 72, -122, -10, 125, 7, 65, 0, 4, 12, 48, 10, 27, 4, 86, 55, 46, 49, 3, 2, 3, 40, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 5, 5, 0, 3, -126, 1, 1, 0, 18, 56, 92, -74, -100, -56, 95, 121, 27, -84, -88, -104, -27, -98, -12, 58, 48, -26, 40, -7, 25, -68, -124, -104, -54, -121, 84, 52, 3, 22, -106, 88, 44, -39, 126, 17, 96, 4, -41, -84, -101, 74, -92, -113, -12, -99, 77, 108, -30, 38, 19, 78, 48, 32, -126, 95, -10, -114, 58, 98, -49, -108, -109, -87, 5, -80, -43, 121, 21, -99, 43, -73, 26, 51, 31, 87, -38, -119, 78, -113, -59, -100, -118, -84, -46, -48, 93, 99, 2, 40, -39, 76, -48, -122, -60, -25, -73, 103, 126, 83, -86, -26, 66, 122, -65, -89, -102, 115, 105, -124, -85, -18, -66, 85, 30, -29, -96, 104, 65, -66, 40, 69, -91, 101, -19, 39, -86, -21, -18, 39, 51, -1, 36, -52, 53, -65, 53, 12, -62, -97, -45, -26, 113, -20, 102, 56, 102, 104, 37, 17, 57, -96, -83, -71, 106, 63, -64, -122, 61, 59, 8, -123, 108, 22, 62, -58, -105, 88, 38, 96, -6, -29, -114, 105, 110, -102, -72, 109, -33, 56, 61, 52, 70, -75, -92, 97, -9, -6, -64, 53, -76, 81, -100, 90, -50, 19, -87, 30, -24, -53, 109, -75, 45, -38, 14, 119, -31, 44, -30, -93, -76, 14, 97, -53, -107, 60, 30, -102, 68, 12, 26, 76, -114, 73, -13, -127, 21, 94, -42, 94, 30, -50, -3, 116, 41, -3, -89, 23, -27, -49, -3, -95, 119, -104, -45, 112, 35, 66, 59, 84, 116, 19, -102, -68, -104, 1 }, | |
35 | - new byte[] { 48, -126, 5, -111, 48, -126, 4, 121, -96, 3, 2, 1, 2, 2, 4, 56, 99, -59, -82, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 5, 5, 0, 48, -127, -76, 49, 20, 48, 18, 6, 3, 85, 4, 10, 19, 11, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 49, 64, 48, 62, 6, 3, 85, 4, 11, 20, 55, 119, 119, 119, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 67, 80, 83, 95, 50, 48, 52, 56, 32, 105, 110, 99, 111, 114, 112, 46, 32, 98, 121, 32, 114, 101, 102, 46, 32, 40, 108, 105, 109, 105, 116, 115, 32, 108, 105, 97, 98, 46, 41, 49, 37, 48, 35, 6, 3, 85, 4, 11, 19, 28, 40, 99, 41, 32, 49, 57, 57, 57, 32, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 76, 105, 109, 105, 116, 101, 100, 49, 51, 48, 49, 6, 3, 85, 4, 3, 19, 42, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 32, 65, 117, 116, 104, 111, 114, 105, 116, 121, 32, 40, 50, 48, 52, 56, 41, 48, 30, 23, 13, 48, 56, 48, 56, 50, 53, 49, 56, 49, 52, 50, 54, 90, 23, 13, 49, 56, 48, 56, 50, 53, 49, 56, 52, 52, 50, 54, 90, 48, -126, 1, 52, 49, 11, 48, 9, 6, 3, 85, 4, 6, 19, 2, 85, 83, 49, 22, 48, 20, 6, 3, 85, 4, 10, 19, 13, 69, 110, 116, 114, 117, 115, 116, 44, 32, 73, 110, 99, 46, 49, 56, 48, 54, 6, 3, 85, 4, 11, 19, 47, 65, 78, 68, 32, 65, 68, 68, 73, 84, 73, 79, 78, 65, 76, 32, 84, 69, 82, 77, 83, 32, 71, 79, 86, 69, 82, 78, 73, 78, 71, 32, 85, 83, 69, 32, 65, 78, 68, 32, 82, 69, 76, 73, 65, 78, 67, 69, 49, 71, 48, 69, 6, 3, 85, 4, 11, 19, 62, 67, 80, 83, 32, 67, 79, 78, 84, 65, 73, 78, 83, 32, 73, 77, 80, 79, 82, 84, 65, 78, 84, 32, 76, 73, 77, 73, 84, 65, 84, 73, 79, 78, 83, 32, 79, 70, 32, 87, 65, 82, 82, 65, 78, 84, 73, 69, 83, 32, 65, 78, 68, 32, 76, 73, 65, 66, 73, 76, 73, 84, 89, 49, 57, 48, 55, 6, 3, 85, 4, 11, 19, 48, 119, 119, 119, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 67, 80, 83, 32, 105, 115, 32, 105, 110, 99, 111, 114, 112, 111, 114, 97, 116, 101, 100, 32, 98, 121, 32, 114, 101, 102, 101, 114, 101, 110, 99, 101, 49, 31, 48, 29, 6, 3, 85, 4, 11, 19, 22, 40, 99, 41, 32, 50, 48, 48, 56, 32, 69, 110, 116, 114, 117, 115, 116, 44, 32, 73, 110, 99, 46, 49, 46, 48, 44, 6, 3, 85, 4, 3, 19, 37, 69, 110, 116, 114, 117, 115, 116, 32, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 32, 65, 117, 116, 104, 111, 114, 105, 116, 121, 32, 45, 32, 76, 49, 66, 48, -126, 1, 34, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 1, 5, 0, 3, -126, 1, 15, 0, 48, -126, 1, 10, 2, -126, 1, 1, 0, -36, 33, -11, 104, -7, 122, -50, -121, -14, 120, -33, -40, 59, 77, 6, 125, -58, 36, -28, -87, -51, -99, 1, 86, -28, -10, 113, 23, -86, 127, 117, 34, 24, -28, 116, 109, 27, 62, 86, -43, -79, -90, 30, -35, 89, 38, 83, -54, 6, -26, -70, 11, 111, 55, -69, -88, -58, -100, 21, 59, 6, 27, -121, 12, -62, 26, 77, -45, -127, -82, -37, 80, 101, -91, 58, 100, 79, 48, 52, -102, 43, -87, 31, -3, 43, -47, 56, 113, 25, 104, -14, -114, -21, 123, -55, 64, 60, 72, -60, 25, -79, -73, 16, 37, -17, 68, -89, -26, 119, -101, 125, 34, -102, -34, -40, 94, -39, -61, -50, -55, 113, 34, -69, -82, -17, 5, -42, -14, 23, -25, 86, 120, -31, 83, 5, 74, 38, 115, -72, -57, 73, 103, -109, 35, 15, 86, -78, -113, -35, -55, 89, 5, -27, 99, 21, -76, -121, 126, 64, 70, -23, -75, 0, 123, 3, -76, 13, -28, -106, 103, 44, -34, 27, 89, 11, 26, 31, -72, 99, 68, -82, -63, -41, 68, -121, -60, -111, 89, -100, 0, 67, 109, -58, -33, 10, -80, -79, 4, -51, -2, -66, 48, 94, 58, 37, 114, -35, -94, 62, -19, 70, 58, -57, -92, 92, 92, -28, 37, -14, 19, 7, -24, -82, -38, -101, 25, -101, -94, -39, 96, -99, -50, -112, 71, 106, 97, 123, 64, -24, 20, -62, -2, 47, -124, 90, 102, 23, -64, -105, -45, 73, 56, -34, 99, 2, -97, 2, 3, 1, 0, 1, -93, -126, 1, 38, 48, -126, 1, 34, 48, 14, 6, 3, 85, 29, 15, 1, 1, -1, 4, 4, 3, 2, 1, 6, 48, 15, 6, 3, 85, 29, 19, 1, 1, -1, 4, 5, 48, 3, 1, 1, -1, 48, 51, 6, 8, 43, 6, 1, 5, 5, 7, 1, 1, 4, 39, 48, 37, 48, 35, 6, 8, 43, 6, 1, 5, 5, 7, 48, 1, -122, 23, 104, 116, 116, 112, 58, 47, 47, 111, 99, 115, 112, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 48, 50, 6, 3, 85, 29, 31, 4, 43, 48, 41, 48, 39, -96, 37, -96, 35, -122, 33, 104, 116, 116, 112, 58, 47, 47, 99, 114, 108, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 50, 48, 52, 56, 99, 97, 46, 99, 114, 108, 48, 59, 6, 3, 85, 29, 32, 4, 52, 48, 50, 48, 48, 6, 4, 85, 29, 32, 0, 48, 40, 48, 38, 6, 8, 43, 6, 1, 5, 5, 7, 2, 1, 22, 26, 104, 116, 116, 112, 58, 47, 47, 119, 119, 119, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 67, 80, 83, 48, 29, 6, 3, 85, 29, 14, 4, 22, 4, 20, -11, -14, -106, -120, 125, 13, -13, 42, -7, 78, -25, 52, -96, -67, 70, 126, 19, -42, 22, -56, 48, 31, 6, 3, 85, 29, 35, 4, 24, 48, 22, -128, 20, 85, -28, -127, -47, 17, -128, -66, -40, -119, -71, 8, -93, 49, -7, -95, 36, 9, 22, -71, 112, 48, 25, 6, 9, 42, -122, 72, -122, -10, 125, 7, 65, 0, 4, 12, 48, 10, 27, 4, 86, 55, 46, 49, 3, 2, 0, -127, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 5, 5, 0, 3, -126, 1, 1, 0, 11, 37, 60, 88, -6, -114, -36, -94, 66, 59, 118, 113, 110, 108, -44, 79, 43, -71, 83, 92, -78, 88, -71, -79, -36, 111, 26, -28, -29, -60, 80, -14, 65, -126, -70, -12, 125, -57, -63, -7, -6, -116, 83, -65, -71, 98, -73, 73, -29, 29, 10, -4, 31, -42, -60, 118, 106, -109, -53, 119, 30, 44, 127, -48, 63, 22, 99, 76, 114, 76, 103, 96, 15, -8, -128, -42, -89, -102, -54, -94, 51, -111, 15, 68, -78, 102, 61, -114, 104, 12, 64, -123, 18, 55, -111, -71, -126, 119, 52, 89, 45, 92, -33, -126, 110, 44, -74, 122, -46, 4, -112, 103, 104, 75, 112, -4, 45, -72, -1, -112, 100, 111, 126, -111, -9, -47, 71, 51, -13, 91, -72, 88, 46, 33, -40, 117, 96, 27, 19, -52, -8, -78, -88, -6, 106, -87, 42, 90, 79, 69, -123, 64, -76, -35, 52, 5, -73, 112, -54, 1, -17, -31, -127, -25, 17, 80, -37, 62, -30, -41, 16, 46, 106, 21, 127, -73, -44, -93, 98, -78, -119, 105, 97, 87, -58, 127, -114, -98, -44, 36, 122, -13, -95, 67, 95, -96, 122, -119, -36, 89, -51, 125, -41, 117, -89, -68, 83, -43, 71, 53, -58, 49, 48, 32, -97, -101, -70, -75, -125, -26, -119, 85, 1, 77, -111, 59, -42, -119, 53, -121, 60, -125, 107, 122, 41, -126, -44, 75, -44, -26, 22, 116, -80, 1, 16, -85, 105, 6, 20, 55, 123, -9, 102, 48, 58, -59 }, | |
36 | - new byte[] { 48, -126, 4, 92, 48, -126, 3, 68, -96, 3, 2, 1, 2, 2, 4, 56, 99, -71, 102, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 5, 5, 0, 48, -127, -76, 49, 20, 48, 18, 6, 3, 85, 4, 10, 19, 11, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 49, 64, 48, 62, 6, 3, 85, 4, 11, 20, 55, 119, 119, 119, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 67, 80, 83, 95, 50, 48, 52, 56, 32, 105, 110, 99, 111, 114, 112, 46, 32, 98, 121, 32, 114, 101, 102, 46, 32, 40, 108, 105, 109, 105, 116, 115, 32, 108, 105, 97, 98, 46, 41, 49, 37, 48, 35, 6, 3, 85, 4, 11, 19, 28, 40, 99, 41, 32, 49, 57, 57, 57, 32, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 76, 105, 109, 105, 116, 101, 100, 49, 51, 48, 49, 6, 3, 85, 4, 3, 19, 42, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 32, 65, 117, 116, 104, 111, 114, 105, 116, 121, 32, 40, 50, 48, 52, 56, 41, 48, 30, 23, 13, 57, 57, 49, 50, 50, 52, 49, 55, 53, 48, 53, 49, 90, 23, 13, 49, 57, 49, 50, 50, 52, 49, 56, 50, 48, 53, 49, 90, 48, -127, -76, 49, 20, 48, 18, 6, 3, 85, 4, 10, 19, 11, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 49, 64, 48, 62, 6, 3, 85, 4, 11, 20, 55, 119, 119, 119, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 67, 80, 83, 95, 50, 48, 52, 56, 32, 105, 110, 99, 111, 114, 112, 46, 32, 98, 121, 32, 114, 101, 102, 46, 32, 40, 108, 105, 109, 105, 116, 115, 32, 108, 105, 97, 98, 46, 41, 49, 37, 48, 35, 6, 3, 85, 4, 11, 19, 28, 40, 99, 41, 32, 49, 57, 57, 57, 32, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 76, 105, 109, 105, 116, 101, 100, 49, 51, 48, 49, 6, 3, 85, 4, 3, 19, 42, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 32, 65, 117, 116, 104, 111, 114, 105, 116, 121, 32, 40, 50, 48, 52, 56, 41, 48, -126, 1, 34, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 1, 5, 0, 3, -126, 1, 15, 0, 48, -126, 1, 10, 2, -126, 1, 1, 0, -83, 77, 75, -87, 18, -122, -78, -22, -93, 32, 7, 21, 22, 100, 42, 43, 75, -47, -65, 11, 74, 77, -114, -19, -128, 118, -91, 103, -73, 120, 64, -64, 115, 66, -56, 104, -64, -37, 83, 43, -35, 94, -72, 118, -104, 53, -109, -117, 26, -99, 124, 19, 58, 14, 31, 91, -73, 30, -49, -27, 36, 20, 30, -79, -127, -87, -115, 125, -72, -52, 107, 75, 3, -15, 2, 12, -36, -85, -91, 64, 36, 0, 127, 116, -108, -95, -99, 8, 41, -77, -120, 11, -11, -121, 119, -99, 85, -51, -28, -61, 126, -41, 106, 100, -85, -123, 20, -122, -107, 91, -105, 50, 80, 111, 61, -56, -70, 102, 12, -29, -4, -67, -72, 73, -63, 118, -119, 73, 25, -3, -64, -88, -67, -119, -93, 103, 47, -58, -97, -68, 113, 25, 96, -72, 45, -23, 44, -55, -112, 118, 102, 123, -108, -30, -81, 120, -42, 101, 83, 93, 60, -42, -100, -78, -49, 41, 3, -7, 47, -92, 80, -78, -44, 72, -50, 5, 50, 85, -118, -3, -78, 100, 76, 14, -28, -104, 7, 117, -37, 127, -33, -71, 8, 85, 96, -123, 48, 41, -7, 123, 72, -92, 105, -122, -29, 53, 63, 30, -122, 93, 122, 122, 21, -67, -17, 0, -114, 21, 34, 84, 23, 0, -112, 38, -109, -68, 14, 73, 104, -111, -65, -8, 71, -45, -99, -107, 66, -63, 14, 77, -33, 111, 38, -49, -61, 24, 33, 98, 102, 67, 112, -42, -43, -64, 7, -31, 2, 3, 1, 0, 1, -93, 116, 48, 114, 48, 17, 6, 9, 96, -122, 72, 1, -122, -8, 66, 1, 1, 4, 4, 3, 2, 0, 7, 48, 31, 6, 3, 85, 29, 35, 4, 24, 48, 22, -128, 20, 85, -28, -127, -47, 17, -128, -66, -40, -119, -71, 8, -93, 49, -7, -95, 36, 9, 22, -71, 112, 48, 29, 6, 3, 85, 29, 14, 4, 22, 4, 20, 85, -28, -127, -47, 17, -128, -66, -40, -119, -71, 8, -93, 49, -7, -95, 36, 9, 22, -71, 112, 48, 29, 6, 9, 42, -122, 72, -122, -10, 125, 7, 65, 0, 4, 16, 48, 14, 27, 8, 86, 53, 46, 48, 58, 52, 46, 48, 3, 2, 4, -112, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 5, 5, 0, 3, -126, 1, 1, 0, 89, 71, -84, 33, -124, -118, 23, -55, -100, -119, 83, 30, -70, -128, -123, 26, -58, 60, 78, 62, -79, -100, -74, 124, -58, -110, 93, 24, 100, 2, -29, -45, 6, 8, 17, 97, 124, 99, -29, 43, -99, 49, 3, 112, 118, -46, -93, 40, -96, -12, -69, -102, 99, 115, -19, 109, -27, 42, -37, -19, 20, -87, 43, -58, 54, 17, -48, 43, -21, 7, -117, -91, -38, -98, 92, 25, -99, 86, 18, -11, 84, 41, -56, 5, -19, -78, 18, 42, -115, -12, 3, 27, -1, -25, -110, 16, -121, -80, 58, -75, -61, -99, 5, 55, 18, -93, -57, -12, 21, -71, -43, -92, 57, 22, -101, 83, 58, 35, -111, -15, -88, -126, -94, 106, -120, 104, -63, 121, 2, 34, -68, -86, -90, -42, -82, -33, -80, 20, 95, -72, -121, -48, -35, 124, 127, 123, -1, -81, 28, -49, -26, -37, 7, -83, 94, -37, -123, -99, -48, 43, 13, 51, -37, 4, -47, -26, 73, 64, 19, 43, 118, -5, 62, -23, -100, -119, 15, 21, -50, 24, -80, -123, 120, 33, 79, 107, 79, 14, -6, 54, 103, -51, 7, -14, -1, 8, -48, -30, -34, -39, -65, 42, -81, -72, -121, -122, 33, 60, 4, -54, -73, -108, 104, 127, -49, 60, -23, -104, -41, 56, -1, -20, -64, -39, 80, -16, 46, 75, 88, -82, 70, 111, -48, 46, -61, 96, -38, 114, 85, 114, -67, 76, 69, -98, 97, -70, -65, -124, -127, -110, 3, -47, -46, 105, 124, -59 }, | |
37 | - }; | |
61 | + private static final byte[] T61STRING_CERT = new byte[] { 48, -126, 4, 92, 48, -126, 3, 68, -96, 3, 2, 1, 2, 2, 4, 56, 99, -71, 102, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 5, 5, 0, 48, -127, -76, 49, 20, 48, 18, 6, 3, 85, 4, 10, 19, 11, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 49, 64, 48, 62, 6, 3, 85, 4, 11, 20, 55, 119, 119, 119, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 67, 80, 83, 95, 50, 48, 52, 56, 32, 105, 110, 99, 111, 114, 112, 46, 32, 98, 121, 32, 114, 101, 102, 46, 32, 40, 108, 105, 109, 105, 116, 115, 32, 108, 105, 97, 98, 46, 41, 49, 37, 48, 35, 6, 3, 85, 4, 11, 19, 28, 40, 99, 41, 32, 49, 57, 57, 57, 32, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 76, 105, 109, 105, 116, 101, 100, 49, 51, 48, 49, 6, 3, 85, 4, 3, 19, 42, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 32, 65, 117, 116, 104, 111, 114, 105, 116, 121, 32, 40, 50, 48, 52, 56, 41, 48, 30, 23, 13, 57, 57, 49, 50, 50, 52, 49, 55, 53, 48, 53, 49, 90, 23, 13, 49, 57, 49, 50, 50, 52, 49, 56, 50, 48, 53, 49, 90, 48, -127, -76, 49, 20, 48, 18, 6, 3, 85, 4, 10, 19, 11, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 49, 64, 48, 62, 6, 3, 85, 4, 11, 20, 55, 119, 119, 119, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 67, 80, 83, 95, 50, 48, 52, 56, 32, 105, 110, 99, 111, 114, 112, 46, 32, 98, 121, 32, 114, 101, 102, 46, 32, 40, 108, 105, 109, 105, 116, 115, 32, 108, 105, 97, 98, 46, 41, 49, 37, 48, 35, 6, 3, 85, 4, 11, 19, 28, 40, 99, 41, 32, 49, 57, 57, 57, 32, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 76, 105, 109, 105, 116, 101, 100, 49, 51, 48, 49, 6, 3, 85, 4, 3, 19, 42, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 32, 65, 117, 116, 104, 111, 114, 105, 116, 121, 32, 40, 50, 48, 52, 56, 41, 48, -126, 1, 34, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 1, 5, 0, 3, -126, 1, 15, 0, 48, -126, 1, 10, 2, -126, 1, 1, 0, -83, 77, 75, -87, 18, -122, -78, -22, -93, 32, 7, 21, 22, 100, 42, 43, 75, -47, -65, 11, 74, 77, -114, -19, -128, 118, -91, 103, -73, 120, 64, -64, 115, 66, -56, 104, -64, -37, 83, 43, -35, 94, -72, 118, -104, 53, -109, -117, 26, -99, 124, 19, 58, 14, 31, 91, -73, 30, -49, -27, 36, 20, 30, -79, -127, -87, -115, 125, -72, -52, 107, 75, 3, -15, 2, 12, -36, -85, -91, 64, 36, 0, 127, 116, -108, -95, -99, 8, 41, -77, -120, 11, -11, -121, 119, -99, 85, -51, -28, -61, 126, -41, 106, 100, -85, -123, 20, -122, -107, 91, -105, 50, 80, 111, 61, -56, -70, 102, 12, -29, -4, -67, -72, 73, -63, 118, -119, 73, 25, -3, -64, -88, -67, -119, -93, 103, 47, -58, -97, -68, 113, 25, 96, -72, 45, -23, 44, -55, -112, 118, 102, 123, -108, -30, -81, 120, -42, 101, 83, 93, 60, -42, -100, -78, -49, 41, 3, -7, 47, -92, 80, -78, -44, 72, -50, 5, 50, 85, -118, -3, -78, 100, 76, 14, -28, -104, 7, 117, -37, 127, -33, -71, 8, 85, 96, -123, 48, 41, -7, 123, 72, -92, 105, -122, -29, 53, 63, 30, -122, 93, 122, 122, 21, -67, -17, 0, -114, 21, 34, 84, 23, 0, -112, 38, -109, -68, 14, 73, 104, -111, -65, -8, 71, -45, -99, -107, 66, -63, 14, 77, -33, 111, 38, -49, -61, 24, 33, 98, 102, 67, 112, -42, -43, -64, 7, -31, 2, 3, 1, 0, 1, -93, 116, 48, 114, 48, 17, 6, 9, 96, -122, 72, 1, -122, -8, 66, 1, 1, 4, 4, 3, 2, 0, 7, 48, 31, 6, 3, 85, 29, 35, 4, 24, 48, 22, -128, 20, 85, -28, -127, -47, 17, -128, -66, -40, -119, -71, 8, -93, 49, -7, -95, 36, 9, 22, -71, 112, 48, 29, 6, 3, 85, 29, 14, 4, 22, 4, 20, 85, -28, -127, -47, 17, -128, -66, -40, -119, -71, 8, -93, 49, -7, -95, 36, 9, 22, -71, 112, 48, 29, 6, 9, 42, -122, 72, -122, -10, 125, 7, 65, 0, 4, 16, 48, 14, 27, 8, 86, 53, 46, 48, 58, 52, 46, 48, 3, 2, 4, -112, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 5, 5, 0, 3, -126, 1, 1, 0, 89, 71, -84, 33, -124, -118, 23, -55, -100, -119, 83, 30, -70, -128, -123, 26, -58, 60, 78, 62, -79, -100, -74, 124, -58, -110, 93, 24, 100, 2, -29, -45, 6, 8, 17, 97, 124, 99, -29, 43, -99, 49, 3, 112, 118, -46, -93, 40, -96, -12, -69, -102, 99, 115, -19, 109, -27, 42, -37, -19, 20, -87, 43, -58, 54, 17, -48, 43, -21, 7, -117, -91, -38, -98, 92, 25, -99, 86, 18, -11, 84, 41, -56, 5, -19, -78, 18, 42, -115, -12, 3, 27, -1, -25, -110, 16, -121, -80, 58, -75, -61, -99, 5, 55, 18, -93, -57, -12, 21, -71, -43, -92, 57, 22, -101, 83, 58, 35, -111, -15, -88, -126, -94, 106, -120, 104, -63, 121, 2, 34, -68, -86, -90, -42, -82, -33, -80, 20, 95, -72, -121, -48, -35, 124, 127, 123, -1, -81, 28, -49, -26, -37, 7, -83, 94, -37, -123, -99, -48, 43, 13, 51, -37, 4, -47, -26, 73, 64, 19, 43, 118, -5, 62, -23, -100, -119, 15, 21, -50, 24, -80, -123, 120, 33, 79, 107, 79, 14, -6, 54, 103, -51, 7, -14, -1, 8, -48, -30, -34, -39, -65, 42, -81, -72, -121, -122, 33, 60, 4, -54, -73, -108, 104, 127, -49, 60, -23, -104, -41, 56, -1, -20, -64, -39, 80, -16, 46, 75, 88, -82, 70, 111, -48, 46, -61, 96, -38, 114, 85, 114, -67, 76, 69, -98, 97, -70, -65, -124, -127, -110, 3, -47, -46, 105, 124, -59 }; | |
38 | 62 | |
39 | 63 | /** |
40 | - * ASN1-encoded trusted certificate #946059622 for Entrust.net. This | |
41 | - * certificate uses the TELETEX encoding for its X509 name. | |
64 | + * Confirm DRLCertFactory uses a non-hex format for T61String encoding: http://b/2102191 | |
42 | 65 | */ |
43 | - private final byte[] trustedCert = new byte[] { 48, -126, 4, 92, 48, -126, 3, 68, -96, 3, 2, 1, 2, 2, 4, 56, 99, -71, 102, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 5, 5, 0, 48, -127, -76, 49, 20, 48, 18, 6, 3, 85, 4, 10, 19, 11, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 49, 64, 48, 62, 6, 3, 85, 4, 11, 20, 55, 119, 119, 119, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 67, 80, 83, 95, 50, 48, 52, 56, 32, 105, 110, 99, 111, 114, 112, 46, 32, 98, 121, 32, 114, 101, 102, 46, 32, 40, 108, 105, 109, 105, 116, 115, 32, 108, 105, 97, 98, 46, 41, 49, 37, 48, 35, 6, 3, 85, 4, 11, 19, 28, 40, 99, 41, 32, 49, 57, 57, 57, 32, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 76, 105, 109, 105, 116, 101, 100, 49, 51, 48, 49, 6, 3, 85, 4, 3, 19, 42, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 32, 65, 117, 116, 104, 111, 114, 105, 116, 121, 32, 40, 50, 48, 52, 56, 41, 48, 30, 23, 13, 57, 57, 49, 50, 50, 52, 49, 55, 53, 48, 53, 49, 90, 23, 13, 49, 57, 49, 50, 50, 52, 49, 56, 50, 48, 53, 49, 90, 48, -127, -76, 49, 20, 48, 18, 6, 3, 85, 4, 10, 19, 11, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 49, 64, 48, 62, 6, 3, 85, 4, 11, 20, 55, 119, 119, 119, 46, 101, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 47, 67, 80, 83, 95, 50, 48, 52, 56, 32, 105, 110, 99, 111, 114, 112, 46, 32, 98, 121, 32, 114, 101, 102, 46, 32, 40, 108, 105, 109, 105, 116, 115, 32, 108, 105, 97, 98, 46, 41, 49, 37, 48, 35, 6, 3, 85, 4, 11, 19, 28, 40, 99, 41, 32, 49, 57, 57, 57, 32, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 76, 105, 109, 105, 116, 101, 100, 49, 51, 48, 49, 6, 3, 85, 4, 3, 19, 42, 69, 110, 116, 114, 117, 115, 116, 46, 110, 101, 116, 32, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 32, 65, 117, 116, 104, 111, 114, 105, 116, 121, 32, 40, 50, 48, 52, 56, 41, 48, -126, 1, 34, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 1, 5, 0, 3, -126, 1, 15, 0, 48, -126, 1, 10, 2, -126, 1, 1, 0, -83, 77, 75, -87, 18, -122, -78, -22, -93, 32, 7, 21, 22, 100, 42, 43, 75, -47, -65, 11, 74, 77, -114, -19, -128, 118, -91, 103, -73, 120, 64, -64, 115, 66, -56, 104, -64, -37, 83, 43, -35, 94, -72, 118, -104, 53, -109, -117, 26, -99, 124, 19, 58, 14, 31, 91, -73, 30, -49, -27, 36, 20, 30, -79, -127, -87, -115, 125, -72, -52, 107, 75, 3, -15, 2, 12, -36, -85, -91, 64, 36, 0, 127, 116, -108, -95, -99, 8, 41, -77, -120, 11, -11, -121, 119, -99, 85, -51, -28, -61, 126, -41, 106, 100, -85, -123, 20, -122, -107, 91, -105, 50, 80, 111, 61, -56, -70, 102, 12, -29, -4, -67, -72, 73, -63, 118, -119, 73, 25, -3, -64, -88, -67, -119, -93, 103, 47, -58, -97, -68, 113, 25, 96, -72, 45, -23, 44, -55, -112, 118, 102, 123, -108, -30, -81, 120, -42, 101, 83, 93, 60, -42, -100, -78, -49, 41, 3, -7, 47, -92, 80, -78, -44, 72, -50, 5, 50, 85, -118, -3, -78, 100, 76, 14, -28, -104, 7, 117, -37, 127, -33, -71, 8, 85, 96, -123, 48, 41, -7, 123, 72, -92, 105, -122, -29, 53, 63, 30, -122, 93, 122, 122, 21, -67, -17, 0, -114, 21, 34, 84, 23, 0, -112, 38, -109, -68, 14, 73, 104, -111, -65, -8, 71, -45, -99, -107, 66, -63, 14, 77, -33, 111, 38, -49, -61, 24, 33, 98, 102, 67, 112, -42, -43, -64, 7, -31, 2, 3, 1, 0, 1, -93, 116, 48, 114, 48, 17, 6, 9, 96, -122, 72, 1, -122, -8, 66, 1, 1, 4, 4, 3, 2, 0, 7, 48, 31, 6, 3, 85, 29, 35, 4, 24, 48, 22, -128, 20, 85, -28, -127, -47, 17, -128, -66, -40, -119, -71, 8, -93, 49, -7, -95, 36, 9, 22, -71, 112, 48, 29, 6, 3, 85, 29, 14, 4, 22, 4, 20, 85, -28, -127, -47, 17, -128, -66, -40, -119, -71, 8, -93, 49, -7, -95, 36, 9, 22, -71, 112, 48, 29, 6, 9, 42, -122, 72, -122, -10, 125, 7, 65, 0, 4, 16, 48, 14, 27, 8, 86, 53, 46, 48, 58, 52, 46, 48, 3, 2, 4, -112, 48, 13, 6, 9, 42, -122, 72, -122, -9, 13, 1, 1, 5, 5, 0, 3, -126, 1, 1, 0, 89, 71, -84, 33, -124, -118, 23, -55, -100, -119, 83, 30, -70, -128, -123, 26, -58, 60, 78, 62, -79, -100, -74, 124, -58, -110, 93, 24, 100, 2, -29, -45, 6, 8, 17, 97, 124, 99, -29, 43, -99, 49, 3, 112, 118, -46, -93, 40, -96, -12, -69, -102, 99, 115, -19, 109, -27, 42, -37, -19, 20, -87, 43, -58, 54, 17, -48, 43, -21, 7, -117, -91, -38, -98, 92, 25, -99, 86, 18, -11, 84, 41, -56, 5, -19, -78, 18, 42, -115, -12, 3, 27, -1, -25, -110, 16, -121, -80, 58, -75, -61, -99, 5, 55, 18, -93, -57, -12, 21, -71, -43, -92, 57, 22, -101, 83, 58, 35, -111, -15, -88, -126, -94, 106, -120, 104, -63, 121, 2, 34, -68, -86, -90, -42, -82, -33, -80, 20, 95, -72, -121, -48, -35, 124, 127, 123, -1, -81, 28, -49, -26, -37, 7, -83, 94, -37, -123, -99, -48, 43, 13, 51, -37, 4, -47, -26, 73, 64, 19, 43, 118, -5, 62, -23, -100, -119, 15, 21, -50, 24, -80, -123, 120, 33, 79, 107, 79, 14, -6, 54, 103, -51, 7, -14, -1, 8, -48, -30, -34, -39, -65, 42, -81, -72, -121, -122, 33, 60, 4, -54, -73, -108, 104, 127, -49, 60, -23, -104, -41, 56, -1, -20, -64, -39, 80, -16, 46, 75, 88, -82, 70, 111, -48, 46, -61, 96, -38, 114, 85, 114, -67, 76, 69, -98, 97, -70, -65, -124, -127, -110, 3, -47, -46, 105, 124, -59 }; | |
66 | + public void testGetName() throws Exception { | |
67 | + CertificateFactory certFactBC = CertificateFactory.getInstance("X.509", "BC"); | |
68 | + CertificateFactory certFactDRL = CertificateFactory.getInstance("X.509", "DRLCertFactory"); | |
69 | + | |
70 | + X509Certificate certBC = (X509Certificate) | |
71 | + certFactBC.generateCertificate(new ByteArrayInputStream(T61STRING_CERT)); | |
72 | + X509Certificate certDRL = (X509Certificate) | |
73 | + certFactDRL.generateCertificate(new ByteArrayInputStream(T61STRING_CERT)); | |
74 | + | |
75 | + assertEquals(certBC, certDRL); | |
76 | + | |
77 | + assertEquals(certBC.getSubjectX500Principal(), certBC.getSubjectX500Principal()); | |
78 | + assertEquals(certDRL.getIssuerX500Principal(), certDRL.getIssuerX500Principal()); | |
79 | + | |
80 | + assertEquals(certBC.getSubjectX500Principal(), certDRL.getSubjectX500Principal()); | |
81 | + assertEquals(certBC.getIssuerX500Principal(), certDRL.getIssuerX500Principal()); | |
82 | + | |
83 | + String[] formats = { | |
84 | + X500Principal.CANONICAL, | |
85 | + X500Principal.RFC1779, | |
86 | + X500Principal.RFC2253 | |
87 | + }; | |
88 | + for (String format : formats) { | |
89 | + assertEquals(certBC.getSubjectX500Principal().getName(format), | |
90 | + certDRL.getSubjectX500Principal().getName(format)); | |
91 | + assertEquals(certBC.getIssuerX500Principal().getName(format), | |
92 | + certDRL.getIssuerX500Principal().getName(format)); | |
93 | + } | |
94 | + String expected = "" | |
95 | + + "cn=entrust.net certification authority (2048)," | |
96 | + + "ou=(c) 1999 entrust.net limited," | |
97 | + + "ou=www.entrust.net/cps_2048 incorp. by ref. (limits liab.)," | |
98 | + + "o=entrust.net"; | |
99 | + assertEquals(expected, | |
100 | + certBC.getSubjectX500Principal().getName(X500Principal.CANONICAL)); | |
101 | + | |
102 | + } | |
103 | +} | |
104 | + | |
105 | +class SerializableTester<T> { | |
44 | 106 | |
45 | - public void testTrustAndRemoteCertificatesWithDifferentEncodings() | |
46 | - throws IOException, CertificateException, KeyStoreException, | |
47 | - InvalidAlgorithmParameterException, CertPathValidatorException { | |
107 | + private final String golden; | |
108 | + private final T value; | |
48 | 109 | |
49 | - X509CertPathImpl certPath = new X509CertPathImpl(Arrays.asList( | |
50 | - new X509CertImpl(serviceSprintComCertChain[0]), | |
51 | - new X509CertImpl(serviceSprintComCertChain[1]), | |
52 | - new X509CertImpl(serviceSprintComCertChain[2]))); | |
110 | + public SerializableTester(T value, String golden) { | |
111 | + this.golden = golden; | |
112 | + this.value = value; | |
113 | + } | |
114 | + | |
115 | + protected void verify(T deserialized) {} | |
116 | + | |
117 | + public void test() { | |
118 | + try { | |
119 | + if (golden == null || golden.length() == 0) { | |
120 | + fail("No golden value supplied! Consider using this: " | |
121 | + + hexEncode(serialize(value))); | |
122 | + } | |
123 | + | |
124 | + // just a sanity check! if this fails, verify() is probably broken | |
125 | + verify(value); | |
126 | + | |
127 | + @SuppressWarnings("unchecked") // deserialize should return the proper type | |
128 | + T deserialized = (T) deserialize(hexDecode(golden)); | |
129 | + assertEquals("User-constructed value doesn't equal deserialized golden value", | |
130 | + value, deserialized); | |
131 | + verify(deserialized); | |
132 | + | |
133 | + @SuppressWarnings("unchecked") // deserialize should return the proper type | |
134 | + T reserialized = (T) deserialize(serialize(value)); | |
135 | + assertEquals("User-constructed value doesn't equal itself, reserialized", | |
136 | + value, reserialized); | |
137 | + verify(reserialized); | |
53 | 138 | |
54 | - Set<TrustAnchor> trustAnchors = new HashSet<TrustAnchor>(); | |
55 | - trustAnchors.add(new TrustAnchor(new X509CertificateObject( | |
56 | - new X509CertificateStructure( | |
57 | - (ASN1Sequence) new ASN1InputStream(trustedCert).readObject())), null)); | |
139 | + } catch (Exception e) { | |
140 | + Error failure = new AssertionFailedError(); | |
141 | + failure.initCause(e); | |
142 | + throw failure; | |
143 | + } | |
144 | + } | |
145 | + | |
146 | + private byte[] serialize(Object object) throws IOException { | |
147 | + ByteArrayOutputStream out = new ByteArrayOutputStream(); | |
148 | + new ObjectOutputStream(out).writeObject(object); | |
149 | + return out.toByteArray(); | |
150 | + } | |
58 | 151 | |
59 | - IndexedPKIXParameters indexedPKIXParameters = new IndexedPKIXParameters(trustAnchors); | |
60 | - indexedPKIXParameters.setRevocationEnabled(false); | |
152 | + private Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException { | |
153 | + ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bytes)); | |
154 | + Object result = in.readObject(); | |
155 | + assertEquals(-1, in.read()); | |
156 | + return result; | |
157 | + } | |
158 | + | |
159 | + private String hexEncode(byte[] bytes) { | |
160 | + StringBuilder result = new StringBuilder(bytes.length * 2); | |
161 | + for (byte b : bytes) { | |
162 | + result.append(String.format("%02x", b)); | |
163 | + } | |
164 | + return result.toString(); | |
165 | + } | |
61 | 166 | |
62 | - new PKIXCertPathValidatorSpi().engineValidate(certPath, indexedPKIXParameters); | |
63 | - // completing normally indicates that the certificate was valid | |
167 | + private byte[] hexDecode(String s) { | |
168 | + byte[] result = new byte[s.length() / 2]; | |
169 | + for (int i = 0; i < result.length; i++) { | |
170 | + result[i] = (byte) Integer.parseInt(s.substring(i*2, i*2 + 2), 16); | |
171 | + } | |
172 | + return result; | |
64 | 173 | } |
65 | 174 | } |
@@ -39,16 +39,13 @@ import java.security.AccessControlContext; | ||
39 | 39 | import java.security.AccessController; |
40 | 40 | import java.security.ProtectionDomain; |
41 | 41 | |
42 | -import org.apache.harmony.security.tests.support.acl.PrincipalImpl; | |
43 | - | |
44 | - | |
45 | 42 | /** |
46 | 43 | * Tests for <code>Subject</code> class constructors and methods. |
47 | - * | |
44 | + * | |
48 | 45 | */ |
49 | -@TestTargetClass(Subject.class) | |
46 | +@TestTargetClass(Subject.class) | |
50 | 47 | public class SubjectTest extends TestCase { |
51 | - | |
48 | + | |
52 | 49 | SecurityManager old; |
53 | 50 | |
54 | 51 | @Override |
@@ -64,7 +61,7 @@ public class SubjectTest extends TestCase { | ||
64 | 61 | } |
65 | 62 | |
66 | 63 | /** |
67 | - * @tests javax.security.auth.Subject#Subject() | |
64 | + * @tests javax.security.auth.Subject#Subject() | |
68 | 65 | */ |
69 | 66 | @TestTargetNew( |
70 | 67 | level = TestLevel.COMPLETE, |
@@ -83,83 +80,7 @@ public class SubjectTest extends TestCase { | ||
83 | 80 | fail("Unexpected exception: " + e); |
84 | 81 | } |
85 | 82 | } |
86 | - | |
87 | - /** | |
88 | - * @tests javax.security.auth.Subject#Subject(boolean readOnly, | |
89 | - * Set<? extends Principal> principals, | |
90 | - * Set<?> pubCredentials, | |
91 | - * Set<?> privCredentials) | |
92 | - */ | |
93 | - @TestTargetNew( | |
94 | - level = TestLevel.COMPLETE, | |
95 | - notes = "", | |
96 | - method = "Subject", | |
97 | - args = {boolean.class, Set.class, Set.class, Set.class} | |
98 | - ) | |
99 | - public void test_Constructor_02() { | |
100 | - Set <Principal> principal = new HashSet<Principal>(); | |
101 | - Set <Object> pubCredentials = new HashSet<Object>(); | |
102 | - Set <Object> privCredentials = new HashSet<Object>(); | |
103 | - Principal pr1 = new PrincipalImpl("TestPrincipal1"); | |
104 | - Principal pr2 = new PrincipalImpl("TestPrincipal2"); | |
105 | - principal.add(pr1); | |
106 | - principal.add(pr2); | |
107 | - Object pubCredential1 = new Object(); | |
108 | - Object pubCredential2 = new Object(); | |
109 | - pubCredentials.add(pubCredential1); | |
110 | - pubCredentials.add(pubCredential2); | |
111 | - Object privCredential1 = new Object(); | |
112 | - Object privCredential2 = new Object(); | |
113 | - privCredentials.add(privCredential1); | |
114 | - privCredentials.add(privCredential2); | |
115 | - | |
116 | - try { | |
117 | - Subject s = new Subject(true, principal, pubCredentials, privCredentials); | |
118 | - assertNotNull("Null object returned", s); | |
119 | - assertTrue("Not read-only object", s.isReadOnly()); | |
120 | - assertFalse("Set of principal is empty", s.getPrincipals().isEmpty()); | |
121 | - assertFalse("Set of private credentials is empty", s.getPrivateCredentials().isEmpty()); | |
122 | - assertFalse("Set of public credentials is empty", s.getPublicCredentials().isEmpty()); | |
123 | - } catch (Exception e) { | |
124 | - fail("Unexpected exception: " + e); | |
125 | - } | |
126 | - | |
127 | - try { | |
128 | - Subject s = new Subject(false, principal, pubCredentials, privCredentials); | |
129 | - assertNotNull("Null object returned", s); | |
130 | - assertFalse("Read-only object", s.isReadOnly()); | |
131 | - assertFalse("Set of principal is empty", s.getPrincipals().isEmpty()); | |
132 | - assertFalse("Set of private credentials is empty", s.getPrivateCredentials().isEmpty()); | |
133 | - assertFalse("Set of public credentials is empty", s.getPublicCredentials().isEmpty()); | |
134 | - } catch (Exception e) { | |
135 | - fail("Unexpected exception: " + e); | |
136 | - } | |
137 | - | |
138 | - try { | |
139 | - Subject s = new Subject(true, null, pubCredentials, privCredentials); | |
140 | - fail("NullPointerException wasn't thrown"); | |
141 | - } catch (NullPointerException npe) { | |
142 | - } | |
143 | - | |
144 | - try { | |
145 | - Subject s = new Subject(true, principal, null, privCredentials); | |
146 | - fail("NullPointerException wasn't thrown"); | |
147 | - } catch (NullPointerException npe) { | |
148 | - } | |
149 | - | |
150 | - try { | |
151 | - Subject s = new Subject(true, principal, pubCredentials, null); | |
152 | - fail("NullPointerException wasn't thrown"); | |
153 | - } catch (NullPointerException npe) { | |
154 | - } | |
155 | - | |
156 | - try { | |
157 | - Subject s = new Subject(true, null, null, null); | |
158 | - fail("NullPointerException wasn't thrown"); | |
159 | - } catch (NullPointerException npe) { | |
160 | - } | |
161 | - } | |
162 | - | |
83 | + | |
163 | 84 | /** |
164 | 85 | * @tests javax.security.auth.Subject#doAs(Subject subject, PrivilegedAction action) |
165 | 86 | */ |
@@ -173,44 +94,26 @@ public class SubjectTest extends TestCase { | ||
173 | 94 | Subject subj = new Subject(); |
174 | 95 | PrivilegedAction<Object> pa = new myPrivilegedAction(); |
175 | 96 | PrivilegedAction<Object> paNull = null; |
176 | - | |
97 | + | |
177 | 98 | try { |
178 | 99 | Object obj = Subject.doAs(null, pa); |
179 | 100 | } catch (Exception e) { |
180 | 101 | fail("Unexpected exception: " + e); |
181 | 102 | } |
182 | - | |
103 | + | |
183 | 104 | try { |
184 | 105 | Object obj = Subject.doAs(subj, pa); |
185 | 106 | } catch (Exception e) { |
186 | 107 | fail("Unexpected exception: " + e); |
187 | 108 | } |
188 | - | |
109 | + | |
189 | 110 | try { |
190 | 111 | Object obj = Subject.doAs(subj, paNull); |
191 | 112 | fail("NullPointerException wasn't thrown"); |
192 | 113 | } catch (NullPointerException npe) { |
193 | 114 | } |
194 | - | |
195 | - class TestSecurityManager extends SecurityManager { | |
196 | - @Override | |
197 | - public void checkPermission(Permission permission) { | |
198 | - if (permission instanceof AuthPermission | |
199 | - && "doAs".equals(permission.getName())) { | |
200 | - throw new SecurityException(); | |
201 | - } | |
202 | - super.checkPermission(permission); | |
203 | - } | |
204 | - } | |
205 | - TestSecurityManager s = new TestSecurityManager(); | |
206 | - System.setSecurityManager(s); | |
207 | - try { | |
208 | - Object obj = Subject.doAs(subj, pa); | |
209 | - fail("SecurityException wasn't thrown"); | |
210 | - } catch (SecurityException se) { | |
211 | - } | |
212 | 115 | } |
213 | - | |
116 | + | |
214 | 117 | /** |
215 | 118 | * @tests javax.security.auth.Subject#doAs(Subject subject, PrivilegedExceptionAction action) |
216 | 119 | */ |
@@ -224,19 +127,19 @@ public class SubjectTest extends TestCase { | ||
224 | 127 | Subject subj = new Subject(); |
225 | 128 | PrivilegedExceptionAction<Object> pea = new myPrivilegedExceptionAction(); |
226 | 129 | PrivilegedExceptionAction<Object> peaNull = null; |
227 | - | |
130 | + | |
228 | 131 | try { |
229 | 132 | Object obj = Subject.doAs(null, pea); |
230 | 133 | } catch (Exception e) { |
231 | 134 | fail("Unexpected exception: " + e); |
232 | 135 | } |
233 | - | |
136 | + | |
234 | 137 | try { |
235 | 138 | Object obj = Subject.doAs(subj, pea); |
236 | 139 | } catch (Exception e) { |
237 | 140 | fail("Unexpected exception: " + e); |
238 | 141 | } |
239 | - | |
142 | + | |
240 | 143 | try { |
241 | 144 | Object obj = Subject.doAs(subj, peaNull); |
242 | 145 | fail("NullPointerException wasn't thrown"); |
@@ -244,7 +147,7 @@ public class SubjectTest extends TestCase { | ||
244 | 147 | } catch (Exception e) { |
245 | 148 | fail(e + " was thrown instead of NullPointerException"); |
246 | 149 | } |
247 | - | |
150 | + | |
248 | 151 | try { |
249 | 152 | Subject.doAs(subj, new PrivilegedExceptionAction<Object>(){ |
250 | 153 | public Object run() throws PrivilegedActionException { |
@@ -254,30 +157,10 @@ public class SubjectTest extends TestCase { | ||
254 | 157 | fail("PrivilegedActionException wasn't thrown"); |
255 | 158 | } catch (PrivilegedActionException e) { |
256 | 159 | } |
257 | - | |
258 | - class TestSecurityManager extends SecurityManager { | |
259 | - @Override | |
260 | - public void checkPermission(Permission permission) { | |
261 | - if (permission instanceof AuthPermission | |
262 | - && "doAs".equals(permission.getName())) { | |
263 | - throw new SecurityException(); | |
264 | - } | |
265 | - super.checkPermission(permission); | |
266 | - } | |
267 | - } | |
268 | - TestSecurityManager s = new TestSecurityManager(); | |
269 | - System.setSecurityManager(s); | |
270 | - try { | |
271 | - Object obj = Subject.doAs(subj, pea); | |
272 | - fail("SecurityException wasn't thrown"); | |
273 | - } catch (SecurityException se) { | |
274 | - } catch (Exception e) { | |
275 | - fail(e + " was thrown instead of SecurityException"); | |
276 | - } | |
277 | 160 | } |
278 | - | |
161 | + | |
279 | 162 | /** |
280 | - * @tests javax.security.auth.Subject#doAsPrivileged(Subject subject, | |
163 | + * @tests javax.security.auth.Subject#doAsPrivileged(Subject subject, | |
281 | 164 | * PrivilegedAction action, |
282 | 165 | * AccessControlContext acc) |
283 | 166 | */ |
@@ -292,46 +175,28 @@ public class SubjectTest extends TestCase { | ||
292 | 175 | PrivilegedAction<Object> pa = new myPrivilegedAction(); |
293 | 176 | PrivilegedAction<Object> paNull = null; |
294 | 177 | AccessControlContext acc = AccessController.getContext(); |
295 | - | |
178 | + | |
296 | 179 | try { |
297 | 180 | Object obj = Subject.doAsPrivileged(null, pa, acc); |
298 | 181 | } catch (Exception e) { |
299 | 182 | fail("Unexpected exception: " + e); |
300 | 183 | } |
301 | - | |
184 | + | |
302 | 185 | try { |
303 | 186 | Object obj = Subject.doAsPrivileged(subj, pa, acc); |
304 | 187 | } catch (Exception e) { |
305 | 188 | fail("Unexpected exception: " + e); |
306 | 189 | } |
307 | - | |
190 | + | |
308 | 191 | try { |
309 | 192 | Object obj = Subject.doAsPrivileged(subj, paNull, acc); |
310 | 193 | fail("NullPointerException wasn't thrown"); |
311 | 194 | } catch (NullPointerException npe) { |
312 | 195 | } |
313 | - | |
314 | - class TestSecurityManager extends SecurityManager { | |
315 | - @Override | |
316 | - public void checkPermission(Permission permission) { | |
317 | - if (permission instanceof AuthPermission | |
318 | - && "doAsPrivileged".equals(permission.getName())) { | |
319 | - throw new SecurityException(); | |
320 | - } | |
321 | - super.checkPermission(permission); | |
322 | - } | |
323 | - } | |
324 | - TestSecurityManager s = new TestSecurityManager(); | |
325 | - System.setSecurityManager(s); | |
326 | - try { | |
327 | - Object obj = Subject.doAsPrivileged(subj, pa, acc); | |
328 | - fail("SecurityException wasn't thrown"); | |
329 | - } catch (SecurityException se) { | |
330 | - } | |
331 | 196 | } |
332 | - | |
197 | + | |
333 | 198 | /** |
334 | - * @tests javax.security.auth.Subject#doAsPrivileged(Subject subject, | |
199 | + * @tests javax.security.auth.Subject#doAsPrivileged(Subject subject, | |
335 | 200 | * PrivilegedExceptionAction action, |
336 | 201 | * AccessControlContext acc) |
337 | 202 | */ |
@@ -346,19 +211,19 @@ public class SubjectTest extends TestCase { | ||
346 | 211 | PrivilegedExceptionAction<Object> pea = new myPrivilegedExceptionAction(); |
347 | 212 | PrivilegedExceptionAction<Object> peaNull = null; |
348 | 213 | AccessControlContext acc = AccessController.getContext(); |
349 | - | |
214 | + | |
350 | 215 | try { |
351 | 216 | Object obj = Subject.doAsPrivileged(null, pea, acc); |
352 | 217 | } catch (Exception e) { |
353 | 218 | fail("Unexpected exception: " + e); |
354 | 219 | } |
355 | - | |
220 | + | |
356 | 221 | try { |
357 | 222 | Object obj = Subject.doAsPrivileged(subj, pea, acc); |
358 | 223 | } catch (Exception e) { |
359 | 224 | fail("Unexpected exception: " + e); |
360 | 225 | } |
361 | - | |
226 | + | |
362 | 227 | try { |
363 | 228 | Object obj = Subject.doAsPrivileged(subj, peaNull, acc); |
364 | 229 | fail("NullPointerException wasn't thrown"); |
@@ -366,7 +231,7 @@ public class SubjectTest extends TestCase { | ||
366 | 231 | } catch (Exception e) { |
367 | 232 | fail(e + " was thrown instead of NullPointerException"); |
368 | 233 | } |
369 | - | |
234 | + | |
370 | 235 | try { |
371 | 236 | Subject.doAsPrivileged(subj, new PrivilegedExceptionAction<Object>(){ |
372 | 237 | public Object run() throws PrivilegedActionException { |
@@ -376,220 +241,8 @@ public class SubjectTest extends TestCase { | ||
376 | 241 | fail("PrivilegedActionException wasn't thrown"); |
377 | 242 | } catch (PrivilegedActionException e) { |
378 | 243 | } |
379 | - | |
380 | - class TestSecurityManager extends SecurityManager { | |
381 | - @Override | |
382 | - public void checkPermission(Permission permission) { | |
383 | - if (permission instanceof AuthPermission | |
384 | - && "doAsPrivileged".equals(permission.getName())) { | |
385 | - throw new SecurityException(); | |
386 | - } | |
387 | - super.checkPermission(permission); | |
388 | - } | |
389 | - } | |
390 | - TestSecurityManager s = new TestSecurityManager(); | |
391 | - System.setSecurityManager(s); | |
392 | - try { | |
393 | - Object obj = Subject.doAsPrivileged(subj, pea, acc); | |
394 | - fail("SecurityException wasn't thrown"); | |
395 | - } catch (SecurityException se) { | |
396 | - } catch (Exception e) { | |
397 | - fail(e + " was thrown instead of SecurityException"); | |
398 | - } | |
399 | - } | |
400 | - | |
401 | - /** | |
402 | - * @tests javax.security.auth.Subject#equals(Object o) | |
403 | - */ | |
404 | - @TestTargetNew( | |
405 | - level = TestLevel.SUFFICIENT, | |
406 | - notes = "SecurityException wasn't tested", | |
407 | - method = "equals", | |
408 | - args = {Object.class} | |
409 | - ) | |
410 | - public void test_equals() { | |
411 | - Set <Principal> principal = new HashSet<Principal>(); | |
412 | - Set <Principal> principal1 = new HashSet<Principal>(); | |
413 | - Set <Object> pubCredentials = new HashSet<Object>(); | |
414 | - Set <Object> privCredentials = new HashSet<Object>(); | |
415 | - Principal pr1 = new PrincipalImpl("TestPrincipal1"); | |
416 | - Principal pr2 = new PrincipalImpl("TestPrincipal2"); | |
417 | - principal.add(pr1); | |
418 | - principal.add(pr2); | |
419 | - principal1.add(pr1); | |
420 | - Object pubCredential1 = new Object(); | |
421 | - Object pubCredential2 = new Object(); | |
422 | - pubCredentials.add(pubCredential1); | |
423 | - pubCredentials.add(pubCredential2); | |
424 | - Object privCredential1 = new Object(); | |
425 | - Object privCredential2 = new Object(); | |
426 | - privCredentials.add(privCredential1); | |
427 | - privCredentials.add(privCredential2); | |
428 | - | |
429 | - Subject s1 = new Subject(true, principal, pubCredentials, privCredentials); | |
430 | - Subject s2 = new Subject(true, principal1, pubCredentials, privCredentials); | |
431 | - Subject s3 = new Subject(true, principal, pubCredentials, privCredentials); | |
432 | - | |
433 | - try { | |
434 | - assertTrue(s1.equals(s1)); | |
435 | - assertFalse(s1.equals(s2)); | |
436 | - assertTrue(s1.equals(s3)); | |
437 | - assertFalse(s1.equals(new Object())); | |
438 | - } catch (Exception e) { | |
439 | - fail("Unexpected exception: " + e); | |
440 | - } | |
441 | - | |
442 | - | |
443 | - class TestSecurityManager extends SecurityManager { | |
444 | - @Override | |
445 | - public void checkPermission(Permission permission) { | |
446 | - if (permission instanceof PrivateCredentialPermission | |
447 | - && "equals".equals(permission.getName())) { | |
448 | - throw new SecurityException(); | |
449 | - } | |
450 | - super.checkPermission(permission); | |
451 | - } | |
452 | - } | |
453 | - TestSecurityManager s = new TestSecurityManager(); | |
454 | - System.setSecurityManager(s); | |
455 | - try { | |
456 | - s1.equals(s1); | |
457 | - //fail("SecurityException wasn't thrown"); | |
458 | - } catch (SecurityException se) { | |
459 | - } | |
460 | - } | |
461 | - | |
462 | - /** | |
463 | - * @tests javax.security.auth.Subject#getPrincipals() | |
464 | - * @tests javax.security.auth.Subject#getPrivateCredentials() | |
465 | - * @tests javax.security.auth.Subject#getPublicCredentials() | |
466 | - * @tests javax.security.auth.Subject#isReadOnly() | |
467 | - * @tests javax.security.auth.Subject#setReadOnly() | |
468 | - */ | |
469 | - @TestTargets({ | |
470 | - @TestTargetNew( | |
471 | - level = TestLevel.COMPLETE, | |
472 | - notes = "", | |
473 | - method = "getPrincipals", | |
474 | - args = {} | |
475 | - ), | |
476 | - @TestTargetNew( | |
477 | - level = TestLevel.COMPLETE, | |
478 | - notes = "", | |
479 | - method = "getPrivateCredentials", | |
480 | - args = {} | |
481 | - ), | |
482 | - @TestTargetNew( | |
483 | - level = TestLevel.COMPLETE, | |
484 | - notes = "", | |
485 | - method = "getPublicCredentials", | |
486 | - args = {} | |
487 | - ) | |
488 | - }) | |
489 | - public void test_getPrincipals() { | |
490 | - Set <Principal> principal = new HashSet<Principal>(); | |
491 | - Set <Object> pubCredentials = new HashSet<Object>(); | |
492 | - Set <Object> privCredentials = new HashSet<Object>(); | |
493 | - Principal pr1 = new PrincipalImpl("TestPrincipal1"); | |
494 | - Principal pr2 = new PrincipalImpl("TestPrincipal2"); | |
495 | - principal.add(pr1); | |
496 | - principal.add(pr2); | |
497 | - Object pubCredential1 = new Object(); | |
498 | - pubCredentials.add(pubCredential1); | |
499 | - Object privCredential1 = new Object(); | |
500 | - Object privCredential2 = new Object(); | |
501 | - privCredentials.add(privCredential1); | |
502 | - privCredentials.add(privCredential2); | |
503 | - | |
504 | - Subject s = new Subject(false, principal, pubCredentials, privCredentials); | |
505 | - | |
506 | - try { | |
507 | - Set<Principal> pr = s.getPrincipals(); | |
508 | - assertNotNull(pr); | |
509 | - assertEquals(principal.size(), pr.size()); | |
510 | - } catch (Exception e) { | |
511 | - fail("Unexpected exception: " + e); | |
512 | - } | |
513 | - | |
514 | - try { | |
515 | - Set<Object> privC = s.getPrivateCredentials(); | |
516 | - assertNotNull(privC); | |
517 | - assertEquals(privCredentials.size(), privC.size()); | |
518 | - } catch (Exception e) { | |
519 | - fail("Unexpected exception: " + e); | |
520 | - } | |
521 | - | |
522 | - try { | |
523 | - Set<Object> pubC = s.getPublicCredentials(); | |
524 | - assertNotNull(pubC); | |
525 | - assertEquals(pubCredentials.size(), pubC.size()); | |
526 | - } catch (Exception e) { | |
527 | - fail("Unexpected exception: " + e); | |
528 | - } | |
529 | - } | |
530 | - | |
531 | - /** | |
532 | - * @tests javax.security.auth.Subject#isReadOnly() | |
533 | - * @tests javax.security.auth.Subject#setReadOnly() | |
534 | - */ | |
535 | - @TestTargets({ | |
536 | - @TestTargetNew( | |
537 | - level = TestLevel.COMPLETE, | |
538 | - notes = "", | |
539 | - method = "isReadOnly", | |
540 | - args = {} | |
541 | - ), | |
542 | - @TestTargetNew( | |
543 | - level = TestLevel.COMPLETE, | |
544 | - notes = "", | |
545 | - method = "setReadOnly", | |
546 | - args = {} | |
547 | - ) | |
548 | - }) | |
549 | - public void test_ReadOnly() { | |
550 | - Set <Principal> principal = new HashSet<Principal>(); | |
551 | - Set <Object> pubCredentials = new HashSet<Object>(); | |
552 | - Set <Object> privCredentials = new HashSet<Object>(); | |
553 | - Principal pr1 = new PrincipalImpl("TestPrincipal1"); | |
554 | - Principal pr2 = new PrincipalImpl("TestPrincipal2"); | |
555 | - principal.add(pr1); | |
556 | - principal.add(pr2); | |
557 | - Object pubCredential1 = new Object(); | |
558 | - pubCredentials.add(pubCredential1); | |
559 | - Object privCredential1 = new Object(); | |
560 | - Object privCredential2 = new Object(); | |
561 | - privCredentials.add(privCredential1); | |
562 | - privCredentials.add(privCredential2); | |
563 | - | |
564 | - Subject s = new Subject(false, principal, pubCredentials, privCredentials); | |
565 | - | |
566 | - try { | |
567 | - assertFalse(s.isReadOnly()); | |
568 | - s.setReadOnly(); | |
569 | - assertTrue(s.isReadOnly()); | |
570 | - } catch (Exception e) { | |
571 | - fail("Unexpected exception " + e); | |
572 | - } | |
573 | - | |
574 | - class TestSecurityManager extends SecurityManager { | |
575 | - @Override | |
576 | - public void checkPermission(Permission permission) { | |
577 | - if (permission instanceof AuthPermission | |
578 | - && "setReadOnly".equals(permission.getName())) { | |
579 | - throw new SecurityException(); | |
580 | - } | |
581 | - super.checkPermission(permission); | |
582 | - } | |
583 | - } | |
584 | - TestSecurityManager ss = new TestSecurityManager(); | |
585 | - System.setSecurityManager(ss); | |
586 | - try { | |
587 | - s.setReadOnly(); | |
588 | - fail("SecurityException wasn't thrown"); | |
589 | - } catch (SecurityException se) { | |
590 | - } | |
591 | 244 | } |
592 | - | |
245 | + | |
593 | 246 | /** |
594 | 247 | * @tests javax.security.auth.Subject#getSubject(AccessControlContext acc) |
595 | 248 | */ |
@@ -602,32 +255,14 @@ public class SubjectTest extends TestCase { | ||
602 | 255 | public void test_getSubject() { |
603 | 256 | Subject subj = new Subject(); |
604 | 257 | AccessControlContext acc = new AccessControlContext(new ProtectionDomain[0]); |
605 | - | |
258 | + | |
606 | 259 | try { |
607 | 260 | assertNull(Subject.getSubject(acc)); |
608 | 261 | } catch (Exception e) { |
609 | 262 | fail("Unexpected exception " + e); |
610 | 263 | } |
611 | - | |
612 | - class TestSecurityManager extends SecurityManager { | |
613 | - @Override | |
614 | - public void checkPermission(Permission permission) { | |
615 | - if (permission instanceof AuthPermission | |
616 | - && "getSubject".equals(permission.getName())) { | |
617 | - throw new SecurityException(); | |
618 | - } | |
619 | - super.checkPermission(permission); | |
620 | - } | |
621 | - } | |
622 | - TestSecurityManager s = new TestSecurityManager(); | |
623 | - System.setSecurityManager(s); | |
624 | - try { | |
625 | - Subject.getSubject(acc); | |
626 | - fail("SecurityException wasn't thrown"); | |
627 | - } catch (SecurityException se) { | |
628 | - } | |
629 | 264 | } |
630 | - | |
265 | + | |
631 | 266 | /** |
632 | 267 | * @tests javax.security.auth.Subject#toString() |
633 | 268 | */ |
@@ -639,14 +274,14 @@ public class SubjectTest extends TestCase { | ||
639 | 274 | ) |
640 | 275 | public void test_toString() { |
641 | 276 | Subject subj = new Subject(); |
642 | - | |
277 | + | |
643 | 278 | try { |
644 | 279 | assertNotNull("Null returned", subj.toString()); |
645 | 280 | } catch (Exception e) { |
646 | 281 | fail("Unexpected exception: " + e); |
647 | 282 | } |
648 | 283 | } |
649 | - | |
284 | + | |
650 | 285 | /** |
651 | 286 | * @tests javax.security.auth.Subject#hashCode() |
652 | 287 | */ |
@@ -658,115 +293,12 @@ public class SubjectTest extends TestCase { | ||
658 | 293 | ) |
659 | 294 | public void test_hashCode() { |
660 | 295 | Subject subj = new Subject(); |
661 | - | |
296 | + | |
662 | 297 | try { |
663 | 298 | assertNotNull("Null returned", subj.hashCode()); |
664 | 299 | } catch (Exception e) { |
665 | 300 | fail("Unexpected exception: " + e); |
666 | 301 | } |
667 | - | |
668 | - class TestSecurityManager extends SecurityManager { | |
669 | - @Override | |
670 | - public void checkPermission(Permission permission) { | |
671 | - if (permission instanceof AuthPermission | |
672 | - && "hashCode".equals(permission.getName())) { | |
673 | - throw new SecurityException(); | |
674 | - } | |
675 | - super.checkPermission(permission); | |
676 | - } | |
677 | - } | |
678 | - TestSecurityManager s = new TestSecurityManager(); | |
679 | - System.setSecurityManager(s); | |
680 | - try { | |
681 | - subj.hashCode(); | |
682 | - //fail("SecurityException wasn't thrown"); | |
683 | - } catch (SecurityException se) { | |
684 | - } | |
685 | - } | |
686 | - | |
687 | - /** | |
688 | - * @tests javax.security.auth.Subject#getPrincipals(Class<T> c) | |
689 | - * @tests javax.security.auth.Subject#getPrivateCredentials(Class<T> c) | |
690 | - * @tests javax.security.auth.Subject#getPublicCredentials(Class<T> c) | |
691 | - */ | |
692 | - @TestTargets({ | |
693 | - @TestTargetNew( | |
694 | - level = TestLevel.COMPLETE, | |
695 | - notes = "", | |
696 | - method = "getPrincipals", | |
697 | - args = {Class.class} | |
698 | - ), | |
699 | - @TestTargetNew( | |
700 | - level = TestLevel.SUFFICIENT, | |
701 | - notes = "", | |
702 | - method = "getPrivateCredentials", | |
703 | - args = {Class.class} | |
704 | - ), | |
705 | - @TestTargetNew( | |
706 | - level = TestLevel.SUFFICIENT, | |
707 | - notes = "", | |
708 | - method = "getPublicCredentials", | |
709 | - args = {Class.class} | |
710 | - ) | |
711 | - }) | |
712 | - public void test_getPrincipals_Class() { | |
713 | - Set <Principal> principal = new HashSet<Principal>(); | |
714 | - Set <Object> pubCredentials = new HashSet<Object>(); | |
715 | - Set <Object> privCredentials = new HashSet<Object>(); | |
716 | - Principal pr1 = new PrincipalImpl("TestPrincipal1"); | |
717 | - Principal pr2 = new PrincipalImpl("TestPrincipal2"); | |
718 | - principal.add(pr1); | |
719 | - principal.add(pr2); | |
720 | - Object pubCredential1 = new Object(); | |
721 | - pubCredentials.add(pubCredential1); | |
722 | - Object privCredential1 = new Object(); | |
723 | - Object privCredential2 = new Object(); | |
724 | - privCredentials.add(privCredential1); | |
725 | - privCredentials.add(privCredential2); | |
726 | - | |
727 | - Subject s = new Subject(true, principal, pubCredentials, privCredentials); | |
728 | - | |
729 | - try { | |
730 | - Set<Principal> pr = s.getPrincipals(null); | |
731 | - fail("NullPointerException wasn't thrown"); | |
732 | - } catch (NullPointerException npe) { | |
733 | - } | |
734 | - | |
735 | - try { | |
736 | - Set<Object> privC = s.getPrivateCredentials(null); | |
737 | - fail("NullPointerException wasn't thrown"); | |
738 | - } catch (NullPointerException npe) { | |
739 | - } | |
740 | - | |
741 | - try { | |
742 | - Set<Object> pubC = s.getPublicCredentials(null); | |
743 | - fail("NullPointerException wasn't thrown"); | |
744 | - } catch (NullPointerException npe) { | |
745 | - } | |
746 | - | |
747 | - try { | |
748 | - Set<Principal> pr = s.getPrincipals(Principal.class); | |
749 | - assertNotNull(pr); | |
750 | - assertEquals(principal.size(), pr.size()); | |
751 | - } catch (Exception e) { | |
752 | - fail("Unexpected exception: " + e); | |
753 | - } | |
754 | - | |
755 | - try { | |
756 | - Set<Object> privC = s.getPrivateCredentials(Object.class); | |
757 | - assertNotNull(privC); | |
758 | - assertEquals(privCredentials.size(), privC.size()); | |
759 | - } catch (Exception e) { | |
760 | - fail("Unexpected exception: " + e); | |
761 | - } | |
762 | - | |
763 | - try { | |
764 | - Set<Object> pubC = s.getPublicCredentials(Object.class); | |
765 | - assertNotNull(pubC); | |
766 | - assertEquals(pubCredentials.size(), pubC.size()); | |
767 | - } catch (Exception e) { | |
768 | - fail("Unexpected exception: " + e); | |
769 | - } | |
770 | 302 | } |
771 | 303 | } |
772 | 304 |
@@ -39,11 +39,6 @@ public class AllTests { | ||
39 | 39 | suite.addTestSuite(LastOwnerExceptionTest.class); |
40 | 40 | suite.addTestSuite(NotOwnerException2Test.class); |
41 | 41 | suite.addTestSuite(NotOwnerExceptionTest.class); |
42 | - suite.addTestSuite(IPermissionTest.class); | |
43 | - suite.addTestSuite(IGroupTest.class); | |
44 | - suite.addTestSuite(IOwnerTest.class); | |
45 | - suite.addTestSuite(IAclEntryTest.class); | |
46 | - suite.addTestSuite(IAclTest.class); | |
47 | 42 | |
48 | 43 | // $JUnit-END$ |
49 | 44 | return suite; |
@@ -1,213 +0,0 @@ | ||
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 | -package tests.security.acl; | |
19 | - | |
20 | -import dalvik.annotation.TestTargets; | |
21 | -import dalvik.annotation.TestLevel; | |
22 | -import dalvik.annotation.TestTargetNew; | |
23 | -import dalvik.annotation.TestTargetClass; | |
24 | - | |
25 | -import junit.framework.TestCase; | |
26 | - | |
27 | -import java.security.acl.AclEntry; | |
28 | -import java.security.acl.Permission; | |
29 | -import java.security.Principal; | |
30 | -import java.util.Enumeration; | |
31 | -import java.util.Vector; | |
32 | - | |
33 | -import org.apache.harmony.security.tests.support.acl.*; | |
34 | - | |
35 | -@TestTargetClass(AclEntry.class) | |
36 | -public class IAclEntryTest extends TestCase { | |
37 | - | |
38 | - class MyAclEntry extends AclEntryImpl { | |
39 | - public MyAclEntry() { | |
40 | - super(); | |
41 | - } | |
42 | - public MyAclEntry(Principal pr) { | |
43 | - super(pr); | |
44 | - } | |
45 | - } | |
46 | - | |
47 | - | |
48 | - /** | |
49 | - * @tests java.security.acl.AclEntry#addPermission(Permission permission) | |
50 | - * @tests java.security.acl.AclEntry#checkPermission(Permission permission) | |
51 | - * @tests java.security.acl.AclEntry#removePermission(Permission permission) | |
52 | - */ | |
53 | - @TestTargets({ | |
54 | - @TestTargetNew( | |
55 | - level = TestLevel.COMPLETE, | |
56 | - notes = "", | |
57 | - method = "addPermission", | |
58 | - args = {java.security.acl.Permission.class} | |
59 | - ), | |
60 | - @TestTargetNew( | |
61 | - level = TestLevel.COMPLETE, | |
62 | - notes = "", | |
63 | - method = "checkPermission", | |
64 | - args = {java.security.acl.Permission.class} | |
65 | - ), | |
66 | - @TestTargetNew( | |
67 | - level = TestLevel.COMPLETE, | |
68 | - notes = "", | |
69 | - method = "removePermission", | |
70 | - args = {java.security.acl.Permission.class} | |
71 | - ) | |
72 | - }) | |
73 | - public void test_AclEntry01() { | |
74 | - Permission perm = new PermissionImpl("Permission_1"); | |
75 | - MyAclEntry ae = new MyAclEntry(new PrincipalImpl("TestPrincipal")); | |
76 | - try { | |
77 | - assertTrue(ae.addPermission(perm)); | |
78 | - assertFalse(ae.addPermission(perm)); | |
79 | - assertTrue(ae.checkPermission(perm)); | |
80 | - assertTrue(ae.removePermission(perm)); | |
81 | - assertFalse(ae.removePermission(perm)); | |
82 | - assertFalse(ae.checkPermission(perm)); | |
83 | - } catch (Exception ex) { | |
84 | - fail("Unexpected exception " + ex); | |
85 | - } | |
86 | - } | |
87 | - | |
88 | - /** | |
89 | - * @tests java.security.acl.AclEntry#getPrincipal() | |
90 | - * @tests java.security.acl.AclEntry#setPrincipal(Principal user) | |
91 | - */ | |
92 | - @TestTargets({ | |
93 | - @TestTargetNew( | |
94 | - level = TestLevel.COMPLETE, | |
95 | - notes = "", | |
96 | - method = "getPrincipal", | |
97 | - args = {} | |
98 | - ), | |
99 | - @TestTargetNew( | |
100 | - level = TestLevel.COMPLETE, | |
101 | - notes = "", | |
102 | - method = "setPrincipal", | |
103 | - args = {java.security.Principal.class} | |
104 | - ) | |
105 | - }) | |
106 | - public void test_AclEntry02() { | |
107 | - MyAclEntry ae = new MyAclEntry(); | |
108 | - Principal mp = new PrincipalImpl("TestPrincipal"); | |
109 | - try { | |
110 | - assertTrue(ae.setPrincipal(mp)); | |
111 | - Principal p = ae.getPrincipal(); | |
112 | - assertEquals("Names are not equal", p.getName(), mp.getName()); | |
113 | - assertFalse(ae.setPrincipal(mp)); | |
114 | - } catch (Exception ex) { | |
115 | - fail("Unexpected exception " + ex); | |
116 | - } | |
117 | - } | |
118 | - | |
119 | - /** | |
120 | - * @tests java.security.acl.AclEntry#setNegativePermissions() | |
121 | - * @tests java.security.acl.AclEntry#isNegative() | |
122 | - */ | |
123 | - @TestTargets({ | |
124 | - @TestTargetNew( | |
125 | - level = TestLevel.COMPLETE, | |
126 | - notes = "", | |
127 | - method = "setNegativePermissions", | |
128 | - args = {} | |
129 | - ), | |
130 | - @TestTargetNew( | |
131 | - level = TestLevel.COMPLETE, | |
132 | - notes = "", | |
133 | - method = "isNegative", | |
134 | - args = {} | |
135 | - ) | |
136 | - }) | |
137 | - public void test_AclEntry03() { | |
138 | - MyAclEntry ae = new MyAclEntry(new PrincipalImpl("TestPrincipal")); | |
139 | - try { | |
140 | - assertFalse("isNegative() returns TRUE",ae.isNegative()); | |
141 | - ae.setNegativePermissions(); | |
142 | - assertTrue("isNegative() returns FALSE", ae.isNegative()); | |
143 | - } catch (Exception ex) { | |
144 | - fail("Unexpected exception " + ex); | |
145 | - } | |
146 | - } | |
147 | - | |
148 | - /** | |
149 | - * @tests java.security.acl.AclEntry#permissions() | |
150 | - */ | |
151 | - @TestTargetNew( | |
152 | - level = TestLevel.COMPLETE, | |
153 | - notes = "", | |
154 | - method = "permissions", | |
155 | - args = {} | |
156 | - ) | |
157 | - public void test_AclEntry04() { | |
158 | - MyAclEntry ae = new MyAclEntry(new PrincipalImpl("TestPrincipal")); | |
159 | - Permission perm = new PermissionImpl("Permission_1"); | |
160 | - try { | |
161 | - Enumeration en = ae.permissions(); | |
162 | - assertFalse("Not empty enumeration", en.hasMoreElements()); | |
163 | - ae.addPermission(perm); | |
164 | - en = ae.permissions(); | |
165 | - assertTrue("Eempty enumeration", en.hasMoreElements()); | |
166 | - Vector v = new Vector(); | |
167 | - while (en.hasMoreElements()) { | |
168 | - v.addElement(en.nextElement()); | |
169 | - } | |
170 | - assertEquals(v.size(), 1); | |
171 | - assertEquals(v.elementAt(0).toString(), perm.toString()); | |
172 | - } catch (Exception ex) { | |
173 | - fail("Unexpected exception " + ex); | |
174 | - } | |
175 | - } | |
176 | - | |
177 | - /** | |
178 | - * @tests java.security.acl.AclEntry#toString() | |
179 | - */ | |
180 | - @TestTargetNew( | |
181 | - level = TestLevel.COMPLETE, | |
182 | - notes = "", | |
183 | - method = "toString", | |
184 | - args = {} | |
185 | - ) | |
186 | - public void test_AclEntry05() { | |
187 | - MyAclEntry ae = new MyAclEntry(new PrincipalImpl("TestPrincipal")); | |
188 | - try { | |
189 | - String res = ae.toString(); | |
190 | - assertTrue(res.contains("TestPrincipal")); | |
191 | - } catch (Exception ex) { | |
192 | - fail("Unexpected exception " + ex); | |
193 | - } | |
194 | - } | |
195 | - | |
196 | - /** | |
197 | - * @tests java.security.acl.AclEntry#clone() | |
198 | - */ | |
199 | - @TestTargetNew( | |
200 | - level = TestLevel.COMPLETE, | |
201 | - notes = "", | |
202 | - method = "clone", | |
203 | - args = {} | |
204 | - ) | |
205 | - public void test_AclEntry06() { | |
206 | - MyAclEntry ae = new MyAclEntry(new PrincipalImpl("TestPrincipal")); | |
207 | - try { | |
208 | - assertEquals("Objects are not equal", ae.toString(), ae.clone().toString()); | |
209 | - } catch (Exception ex) { | |
210 | - fail("Unexpected exception " + ex); | |
211 | - } | |
212 | - } | |
213 | -} | |
\ No newline at end of file |
@@ -1,230 +0,0 @@ | ||
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 | -package tests.security.acl; | |
19 | - | |
20 | -import dalvik.annotation.TestTargets; | |
21 | -import dalvik.annotation.TestLevel; | |
22 | -import dalvik.annotation.TestTargetNew; | |
23 | -import dalvik.annotation.TestTargetClass; | |
24 | - | |
25 | -import junit.framework.TestCase; | |
26 | - | |
27 | -import java.security.acl.Acl; | |
28 | -import java.security.acl.AclEntry; | |
29 | -import java.security.acl.NotOwnerException; | |
30 | -import java.security.acl.Permission; | |
31 | -import java.security.Principal; | |
32 | -import java.util.Enumeration; | |
33 | -import java.util.Vector; | |
34 | - | |
35 | -import org.apache.harmony.security.tests.support.acl.*; | |
36 | - | |
37 | -@TestTargetClass(Acl.class) | |
38 | -public class IAclTest extends TestCase { | |
39 | - | |
40 | - class MyAcl extends AclImpl { | |
41 | - public MyAcl(Principal principal, String str) { | |
42 | - super(principal, str); | |
43 | - } | |
44 | - } | |
45 | - | |
46 | - | |
47 | - /** | |
48 | - * @tests java.security.acl.Acl#addEntry(Principal caller, AclEntry entry) | |
49 | - * @tests java.security.acl.Acl#removeEntry(Principal caller, AclEntry entry) | |
50 | - */ | |
51 | - @TestTargets({ | |
52 | - @TestTargetNew( | |
53 | - level = TestLevel.COMPLETE, | |
54 | - notes = "", | |
55 | - method = "addEntry", | |
56 | - args = {java.security.Principal.class, java.security.acl.AclEntry.class} | |
57 | - ), | |
58 | - @TestTargetNew( | |
59 | - level = TestLevel.COMPLETE, | |
60 | - notes = "", | |
61 | - method = "removeEntry", | |
62 | - args = {java.security.Principal.class, java.security.acl.AclEntry.class} | |
63 | - ) | |
64 | - }) | |
65 | - public void test_Acl01() { | |
66 | - Principal pr = new PrincipalImpl("TestPrincipal"); | |
67 | - String str = "TestName"; | |
68 | - MyAcl acl = new MyAcl(pr, str); | |
69 | - AclEntry ae = new AclEntryImpl(pr); | |
70 | - try { | |
71 | - assertTrue(acl.addEntry(pr, ae)); | |
72 | - assertFalse(acl.addEntry(pr, ae)); | |
73 | - assertTrue(acl.removeEntry(pr, ae)); | |
74 | - assertFalse(acl.removeEntry(pr, ae)); | |
75 | - } catch (Exception ex) { | |
76 | - fail("Unexpected exception " + ex); | |
77 | - } | |
78 | - | |
79 | - try { | |
80 | - acl.addEntry(new PrincipalImpl("NewPrincipal"), ae); | |
81 | - fail("NotOwnerException was not thrown"); | |
82 | - } catch (NotOwnerException noe) { | |
83 | - //expected | |
84 | - } | |
85 | - | |
86 | - try { | |
87 | - acl.removeEntry(new PrincipalImpl("NewPrincipal"), ae); | |
88 | - fail("NotOwnerException was not thrown"); | |
89 | - } catch (NotOwnerException noe) { | |
90 | - //expected | |
91 | - } | |
92 | - } | |
93 | - | |
94 | - /** | |
95 | - * @tests java.security.acl.Acl#setName(Principal caller, String name) | |
96 | - * @tests java.security.acl.Acl#getName() | |
97 | - */ | |
98 | - @TestTargets({ | |
99 | - @TestTargetNew( | |
100 | - level = TestLevel.COMPLETE, | |
101 | - notes = "", | |
102 | - method = "setName", | |
103 | - args = {java.security.Principal.class, java.lang.String.class} | |
104 | - ), | |
105 | - @TestTargetNew( | |
106 | - level = TestLevel.COMPLETE, | |
107 | - notes = "", | |
108 | - method = "getName", | |
109 | - args = {} | |
110 | - ) | |
111 | - }) | |
112 | - public void test_Acl02() { | |
113 | - Principal pr = new PrincipalImpl("TestPrincipal"); | |
114 | - String str = "TestName"; | |
115 | - String newStr = "NewName"; | |
116 | - MyAcl acl = new MyAcl(pr, str); | |
117 | - try { | |
118 | - assertEquals("Names are not equal", str, acl.getName()); | |
119 | - acl.setName(pr, newStr); | |
120 | - assertEquals("Names are not equal", newStr, acl.getName()); | |
121 | - } catch (Exception ex) { | |
122 | - fail("Unexpected exception " + ex); | |
123 | - } | |
124 | - | |
125 | - try { | |
126 | - acl.setName(new PrincipalImpl("NewPrincipal"), str); | |
127 | - fail("NotOwnerException was not thrown"); | |
128 | - } catch (NotOwnerException noe) { | |
129 | - //expected | |
130 | - } | |
131 | - } | |
132 | - | |
133 | - /** | |
134 | - * @tests java.security.acl.Acl#toString() | |
135 | - */ | |
136 | - @TestTargetNew( | |
137 | - level = TestLevel.COMPLETE, | |
138 | - notes = "", | |
139 | - method = "toString", | |
140 | - args = {} | |
141 | - ) | |
142 | - public void test_Acl03() { | |
143 | - Principal pr = new PrincipalImpl("TestPrincipal"); | |
144 | - String str = "TestName"; | |
145 | - MyAcl acl = new MyAcl(pr, str); | |
146 | - AclEntry ae = new AclEntryImpl(pr); | |
147 | - Permission perm = new PermissionImpl("Permission_1"); | |
148 | - try { | |
149 | - ae.addPermission(perm); | |
150 | - acl.addEntry(pr, ae); | |
151 | - String res = acl.toString(); | |
152 | - assertTrue(res.contains(perm.toString())); | |
153 | - } catch (Exception ex) { | |
154 | - fail("Unexpected exception " + ex); | |
155 | - } | |
156 | - } | |
157 | - | |
158 | - /** | |
159 | - * @tests java.security.acl.Acl#entries() | |
160 | - */ | |
161 | - @TestTargetNew( | |
162 | - level = TestLevel.COMPLETE, | |
163 | - notes = "", | |
164 | - method = "entries", | |
165 | - args = {} | |
166 | - ) | |
167 | - public void test_Acl04() { | |
168 | - Principal pr = new PrincipalImpl("TestPrincipal"); | |
169 | - String str = "TestName"; | |
170 | - MyAcl acl = new MyAcl(pr, str); | |
171 | - AclEntry ae1 = new AclEntryImpl(pr); | |
172 | - try { | |
173 | - ae1.addPermission(new PermissionImpl("Permission_1")); | |
174 | - acl.addEntry(pr, ae1); | |
175 | - Enumeration en = acl.entries(); | |
176 | - Vector v = new Vector(); | |
177 | - while (en.hasMoreElements()) { | |
178 | - v.addElement(en.nextElement()); | |
179 | - } | |
180 | - assertEquals(v.size(), 1); | |
181 | - } catch (Exception ex) { | |
182 | - fail("Unexpected exception " + ex); | |
183 | - } | |
184 | - } | |
185 | - | |
186 | - /** | |
187 | - * @tests java.security.acl.Acl#checkPermission(Principal principal, Permission permission) | |
188 | - * @tests java.security.acl.Acl#getPermissions(Principal principal) | |
189 | - */ | |
190 | - @TestTargets({ | |
191 | - @TestTargetNew( | |
192 | - level = TestLevel.COMPLETE, | |
193 | - notes = "", | |
194 | - method = "checkPermission", | |
195 | - args = {java.security.Principal.class, java.security.acl.Permission.class} | |
196 | - ), | |
197 | - @TestTargetNew( | |
198 | - level = TestLevel.COMPLETE, | |
199 | - notes = "", | |
200 | - method = "getPermissions", | |
201 | - args = {java.security.Principal.class} | |
202 | - ) | |
203 | - }) | |
204 | - public void test_Acl05() { | |
205 | - Principal pr = new PrincipalImpl("TestPrincipal"); | |
206 | - String str = "TestName"; | |
207 | - MyAcl acl = new MyAcl(pr, str); | |
208 | - AclEntry ae = new AclEntryImpl(pr); | |
209 | - Permission perm = new PermissionImpl("Permission_1"); | |
210 | - try { | |
211 | - ae.addPermission(perm); | |
212 | - acl.addEntry(pr, ae); | |
213 | - | |
214 | - //checkPermission verification | |
215 | - assertTrue("Incorrect permission", acl.checkPermission(pr, perm)); | |
216 | - assertFalse(acl.checkPermission(pr, new PermissionImpl("Permission_2"))); | |
217 | - | |
218 | - //getPermissions | |
219 | - Enumeration en = acl.getPermissions(pr); | |
220 | - Vector v = new Vector(); | |
221 | - while (en.hasMoreElements()) { | |
222 | - v.addElement(en.nextElement()); | |
223 | - } | |
224 | - assertEquals(v.size(), 1); | |
225 | - assertEquals(v.elementAt(0).toString(), perm.toString()); | |
226 | - } catch (Exception ex) { | |
227 | - fail("Exception " + ex + " was thrown"); | |
228 | - } | |
229 | - } | |
230 | -} | |
\ No newline at end of file |
@@ -1,101 +0,0 @@ | ||
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 | -package tests.security.acl; | |
19 | - | |
20 | -import dalvik.annotation.TestTargets; | |
21 | -import dalvik.annotation.TestLevel; | |
22 | -import dalvik.annotation.TestTargetNew; | |
23 | -import dalvik.annotation.TestTargetClass; | |
24 | - | |
25 | -import junit.framework.TestCase; | |
26 | - | |
27 | -import java.security.acl.Group; | |
28 | -import java.security.Principal; | |
29 | -import java.util.Enumeration; | |
30 | - | |
31 | -import org.apache.harmony.security.tests.support.acl.*; | |
32 | - | |
33 | -@TestTargetClass(Group.class) | |
34 | -public class IGroupTest extends TestCase { | |
35 | - | |
36 | - class MyGroup extends GroupImpl { | |
37 | - public MyGroup(String str) { | |
38 | - super(str); | |
39 | - } | |
40 | - } | |
41 | - | |
42 | - /** | |
43 | - * @tests java.security.acl.Group#addMember(Principal user) | |
44 | - */ | |
45 | - @TestTargets({ | |
46 | - @TestTargetNew( | |
47 | - level = TestLevel.COMPLETE, | |
48 | - notes = "", | |
49 | - method = "addMember", | |
50 | - args = {java.security.Principal.class} | |
51 | - ), | |
52 | - @TestTargetNew( | |
53 | - level = TestLevel.COMPLETE, | |
54 | - notes = "", | |
55 | - method = "isMember", | |
56 | - args = {java.security.Principal.class} | |
57 | - ), | |
58 | - @TestTargetNew( | |
59 | - level = TestLevel.COMPLETE, | |
60 | - notes = "", | |
61 | - method = "removeMember", | |
62 | - args = {java.security.Principal.class} | |
63 | - ) | |
64 | - }) | |
65 | - public void test_addMember() { | |
66 | - MyGroup gr = new MyGroup("TestOwners"); | |
67 | - Principal pr = new PrincipalImpl("TestPrincipal"); | |
68 | - try { | |
69 | - assertTrue(gr.addMember(pr)); | |
70 | - assertFalse(gr.addMember(pr)); | |
71 | - assertTrue(gr.isMember(pr)); | |
72 | - assertTrue(gr.removeMember(pr)); | |
73 | - assertFalse(gr.isMember(pr)); | |
74 | - assertFalse(gr.removeMember(pr)); | |
75 | - } catch (Exception e) { | |
76 | - fail("Unexpected exception " + e); | |
77 | - } | |
78 | - } | |
79 | - | |
80 | - /** | |
81 | - * @tests java.security.acl.Group#members() | |
82 | - */ | |
83 | - @TestTargetNew( | |
84 | - level = TestLevel.COMPLETE, | |
85 | - notes = "", | |
86 | - method = "members", | |
87 | - args = {} | |
88 | - ) | |
89 | - public void test_members() { | |
90 | - MyGroup gr = new MyGroup("TestOwners"); | |
91 | - Principal pr = new PrincipalImpl("TestPrincipal"); | |
92 | - try { | |
93 | - Enumeration en = gr.members(); | |
94 | - assertFalse("Not empty enumeration", en.hasMoreElements()); | |
95 | - assertTrue(gr.addMember(pr)); | |
96 | - assertTrue("Empty enumeration", en.hasMoreElements()); | |
97 | - } catch (Exception e) { | |
98 | - fail("Unexpected exception " + e); | |
99 | - } | |
100 | - } | |
101 | -} | |
\ No newline at end of file |
@@ -1,148 +0,0 @@ | ||
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 | -package tests.security.acl; | |
19 | - | |
20 | -import dalvik.annotation.TestTargets; | |
21 | -import dalvik.annotation.TestLevel; | |
22 | -import dalvik.annotation.TestTargetNew; | |
23 | -import dalvik.annotation.TestTargetClass; | |
24 | - | |
25 | -import junit.framework.TestCase; | |
26 | - | |
27 | -import java.security.acl.Owner; | |
28 | -import java.security.Principal; | |
29 | -import java.security.acl.NotOwnerException; | |
30 | -import java.security.acl.LastOwnerException; | |
31 | - | |
32 | -import org.apache.harmony.security.tests.support.acl.*; | |
33 | - | |
34 | -@TestTargetClass(Owner.class) | |
35 | -public class IOwnerTest extends TestCase { | |
36 | - | |
37 | - class MyOwner extends OwnerImpl { | |
38 | - public MyOwner(Principal pr) { | |
39 | - super(pr); | |
40 | - } | |
41 | - } | |
42 | - | |
43 | - /** | |
44 | - * @tests java.security.acl.Owner#isOwner(Principal owner) | |
45 | - * | |
46 | - */ | |
47 | - @TestTargetNew( | |
48 | - level = TestLevel.COMPLETE, | |
49 | - notes = "", | |
50 | - method = "isOwner", | |
51 | - args = {java.security.Principal.class} | |
52 | - ) | |
53 | - public void test_isOwner() { | |
54 | - MyOwner mo = new MyOwner(new PrincipalImpl("NewOwner")); | |
55 | - try { | |
56 | - assertFalse("Method returns TRUE", mo.isOwner(new PrincipalImpl("TestOwner"))); | |
57 | - assertTrue("Method returns FALSE", mo.isOwner(new PrincipalImpl("NewOwner"))); | |
58 | - } catch (Exception ex) { | |
59 | - fail("Unexpected exception " + ex); | |
60 | - } | |
61 | - } | |
62 | - | |
63 | - /** | |
64 | - * @tests java.security.acl.Owner#addOwner(Principal caller, Principal owner) | |
65 | - * | |
66 | - */ | |
67 | - @TestTargetNew( | |
68 | - level = TestLevel.COMPLETE, | |
69 | - notes = "", | |
70 | - method = "addOwner", | |
71 | - args = {java.security.Principal.class, java.security.Principal.class} | |
72 | - ) | |
73 | - public void test_addOwner() { | |
74 | - Principal p1 = new PrincipalImpl("Owner"); | |
75 | - Principal p2 = new PrincipalImpl("AclOwner"); | |
76 | - Principal pt = new PrincipalImpl("NewOwner"); | |
77 | - MyOwner mo = new MyOwner(p1); | |
78 | - try { | |
79 | - //add new owner - TRUE expected | |
80 | - assertTrue("Method returns FALSE", mo.addOwner(p1, pt)); | |
81 | - //add existent owner - FALSE expected | |
82 | - assertFalse("Method returns TRUE", mo.addOwner(p1, pt)); | |
83 | - } catch (Exception ex) { | |
84 | - fail("Unexpected exception " + ex); | |
85 | - } | |
86 | - //exception case | |
87 | - try { | |
88 | - mo.addOwner(p2, pt); | |
89 | - fail("NotOwnerException was not thrown"); | |
90 | - } catch (NotOwnerException noe) { | |
91 | - //expected | |
92 | - } | |
93 | - } | |
94 | - | |
95 | - /** | |
96 | - * @tests java.security.acl.Owner#deleteOwner(Principal caller, Principal owner) | |
97 | - * | |
98 | - */ | |
99 | - @TestTargetNew( | |
100 | - level = TestLevel.COMPLETE, | |
101 | - notes = "", | |
102 | - method = "deleteOwner", | |
103 | - args = {java.security.Principal.class, java.security.Principal.class} | |
104 | - ) | |
105 | - public void test_deleteOwner() { | |
106 | - Principal caller = new PrincipalImpl("Owner"); | |
107 | - Principal owner1 = new PrincipalImpl("NewOwner1"); | |
108 | - Principal owner2 = new PrincipalImpl("NewOwner2"); | |
109 | - Principal notCaller = new PrincipalImpl("AclOwner"); | |
110 | - MyOwner mo = new MyOwner(caller); | |
111 | - | |
112 | - try { | |
113 | - if (!mo.isOwner(owner1)) mo.addOwner(caller, owner1); | |
114 | - if (!mo.isOwner(owner2)) mo.addOwner(caller, owner2); | |
115 | - } catch (Exception e) { | |
116 | - fail("Unexpected exception " + e + " was thrown for addOwner"); | |
117 | - } | |
118 | - | |
119 | - try { | |
120 | - //remove existent owner - TRUE expected | |
121 | - assertTrue("Method returns FALSE", mo.deleteOwner(caller, owner1)); | |
122 | - assertFalse("Object presents in the owner list", mo.isOwner(owner1)); | |
123 | - //remove owner which is not part of the list of owners - FALSE expected | |
124 | - assertFalse("Method returns TRUE", mo.deleteOwner(caller, owner1)); | |
125 | - assertTrue("Method returns FALSE", mo.deleteOwner(caller, owner2)); | |
126 | - } catch (Exception ex) { | |
127 | - fail("Unexpected exception " + ex); | |
128 | - } | |
129 | - //exception case - NotOwnerException | |
130 | - try { | |
131 | - mo.deleteOwner(notCaller, owner1); | |
132 | - fail("NotOwnerException was not thrown"); | |
133 | - } catch (NotOwnerException noe) { | |
134 | - //expected | |
135 | - } catch (Exception e) { | |
136 | - fail(e + " was thrown instead of NotOwnerException"); | |
137 | - } | |
138 | - //exception case - LastOwnerException | |
139 | - try { | |
140 | - mo.deleteOwner(caller, owner2); | |
141 | - fail("LastOwnerException was not thrown"); | |
142 | - } catch (LastOwnerException loe) { | |
143 | - //expected | |
144 | - } catch (Exception e) { | |
145 | - fail(e + " was thrown instead of LastOwnerException"); | |
146 | - } | |
147 | - } | |
148 | -} | |
\ No newline at end of file |
@@ -1,80 +0,0 @@ | ||
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 | -package tests.security.acl; | |
19 | - | |
20 | -import dalvik.annotation.TestTargets; | |
21 | -import dalvik.annotation.TestLevel; | |
22 | -import dalvik.annotation.TestTargetNew; | |
23 | -import dalvik.annotation.TestTargetClass; | |
24 | - | |
25 | -import junit.framework.TestCase; | |
26 | - | |
27 | -import java.security.acl.Permission; | |
28 | - | |
29 | -import org.apache.harmony.security.tests.support.acl.*; | |
30 | - | |
31 | -@TestTargetClass(Permission.class) | |
32 | -public class IPermissionTest extends TestCase { | |
33 | - | |
34 | - class MyPermission extends PermissionImpl { | |
35 | - public MyPermission(String str) { | |
36 | - super(str); | |
37 | - } | |
38 | - } | |
39 | - | |
40 | - /** | |
41 | - * @tests java.security.acl.Permission#equals(Object another) | |
42 | - */ | |
43 | - @TestTargetNew( | |
44 | - level = TestLevel.COMPLETE, | |
45 | - notes = "", | |
46 | - method = "equals", | |
47 | - args = {java.lang.Object.class} | |
48 | - ) | |
49 | - public void test_equals() { | |
50 | - try { | |
51 | - MyPermission mp1 = new MyPermission("TestPermission"); | |
52 | - MyPermission mp2 = new MyPermission("NewTestPermission"); | |
53 | - Object another = new Object(); | |
54 | - assertFalse(mp1.equals(another)); | |
55 | - assertFalse(mp1.equals(mp2)); | |
56 | - assertTrue(mp1.equals(new MyPermission("TestPermission"))); | |
57 | - } catch (Exception e) { | |
58 | - fail("Unexpected exception - subtest1"); | |
59 | - } | |
60 | - } | |
61 | - | |
62 | - /** | |
63 | - * @tests java.security.acl.Permission#toString() | |
64 | - */ | |
65 | - @TestTargetNew( | |
66 | - level = TestLevel.COMPLETE, | |
67 | - notes = "", | |
68 | - method = "toString", | |
69 | - args = {} | |
70 | - ) | |
71 | - public void test_toString() { | |
72 | - try { | |
73 | - MyPermission obj = new MyPermission("TestPermission"); | |
74 | - String res = obj.toString(); | |
75 | - assertEquals(res, "TestPermission"); | |
76 | - } catch (Exception e) { | |
77 | - fail("Unexpected exception - subtest2"); | |
78 | - } | |
79 | - } | |
80 | -} | |
\ No newline at end of file |
@@ -80,7 +80,6 @@ public class AllTests { | ||
80 | 80 | // Crashes on RI. |
81 | 81 | // suite.addTestSuite(X509CertSelectorTest.class); |
82 | 82 | suite.addTestSuite(X509Certificate2Test.class); |
83 | - suite.addTestSuite(PolicyNodeTest.class); | |
84 | 83 | |
85 | 84 | // $JUnit-END$ |
86 | 85 | return suite; |
@@ -36,9 +36,9 @@ import java.util.Collection; | ||
36 | 36 | import java.util.Vector; |
37 | 37 | |
38 | 38 | import org.apache.harmony.security.tests.support.cert.MyCertificate; |
39 | + | |
39 | 40 | /** |
40 | - * Tests for <code>CollectionCertStoreParameters</code> | |
41 | - * | |
41 | + * Tests for <code>CollectionCertStoreParameters</code>. | |
42 | 42 | */ |
43 | 43 | @TestTargetClass(CollectionCertStoreParameters.class) |
44 | 44 | public class CollectionCertStoreParametersTest extends TestCase { |
@@ -49,8 +49,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
49 | 49 | |
50 | 50 | /** |
51 | 51 | * Test #1 for <code>CollectionCertStoreParameters()</code> constructor<br> |
52 | - * Assertion: Creates an instance of CollectionCertStoreParameters | |
53 | - * with the default parameter values (an empty and immutable Collection) | |
54 | 52 | */ |
55 | 53 | @TestTargetNew( |
56 | 54 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -66,8 +64,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
66 | 64 | |
67 | 65 | /** |
68 | 66 | * Test #2 for <code>CollectionCertStoreParameters</code> constructor<br> |
69 | - * Assertion: Creates an instance of CollectionCertStoreParameters | |
70 | - * with the default parameter values (an empty and immutable Collection) | |
71 | 67 | */ |
72 | 68 | @TestTargetNew( |
73 | 69 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -93,7 +89,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
93 | 89 | /** |
94 | 90 | * Test #1 for <code>CollectionCertStoreParameters(Collection)</code> |
95 | 91 | * constructor<br> |
96 | - * Assertion: Creates an instance of CollectionCertStoreParameters | |
97 | 92 | */ |
98 | 93 | @TestTargetNew( |
99 | 94 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -110,9 +105,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
110 | 105 | /** |
111 | 106 | * Test #2 for <code>CollectionCertStoreParameters(Collection)</code> |
112 | 107 | * constructor<br> |
113 | - * Assertion: If the specified <code>Collection</code> contains an object | |
114 | - * that is not a <code>Certificate</code> or <code>CRL</code>, that object | |
115 | - * will be ignored by the Collection <code>CertStore</code>. | |
116 | 108 | */ |
117 | 109 | @TestTargetNew( |
118 | 110 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -132,11 +124,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
132 | 124 | /** |
133 | 125 | * Test #3 for <code>CollectionCertStoreParameters(Collection)</code> |
134 | 126 | * constructor<br> |
135 | - * Assertion: The Collection is not copied. Instead, a reference is used. | |
136 | - * This allows the caller to subsequently add or remove Certificates or | |
137 | - * CRLs from the Collection, thus changing the set of Certificates or CRLs | |
138 | - * available to the Collection CertStore. The Collection CertStore will | |
139 | - * not modify the contents of the Collection | |
140 | 127 | */ |
141 | 128 | @TestTargetNew( |
142 | 129 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -149,7 +136,7 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
149 | 136 | // create using empty collection |
150 | 137 | CollectionCertStoreParameters cp = |
151 | 138 | new CollectionCertStoreParameters(certificates); |
152 | - // check that the reference is used | |
139 | + // check that the reference is used | |
153 | 140 | assertTrue("isRefUsed_1", certificates == cp.getCollection()); |
154 | 141 | // check that collection still empty |
155 | 142 | assertTrue("isEmpty", cp.getCollection().isEmpty()); |
@@ -163,8 +150,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
163 | 150 | /** |
164 | 151 | * Test #4 for <code>CollectionCertStoreParameters(Collection)</code> |
165 | 152 | * constructor<br> |
166 | - * Assertion: <code>NullPointerException</code> - if | |
167 | - * <code>collection</code> is <code>null</code> | |
168 | 153 | */ |
169 | 154 | @TestTargetNew( |
170 | 155 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -182,7 +167,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
182 | 167 | |
183 | 168 | /** |
184 | 169 | * Test #1 for <code>clone()</code> method<br> |
185 | - * Assertion: Returns a copy of this object | |
186 | 170 | */ |
187 | 171 | @TestTargetNew( |
188 | 172 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -203,8 +187,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
203 | 187 | |
204 | 188 | /** |
205 | 189 | * Test #2 for <code>clone()</code> method<br> |
206 | - * Assertion: ...only a reference to the <code>Collection</code> | |
207 | - * is copied, and not the contents | |
208 | 190 | */ |
209 | 191 | @TestTargetNew( |
210 | 192 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -225,8 +207,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
225 | 207 | |
226 | 208 | /** |
227 | 209 | * Test #3 for <code>clone()</code> method<br> |
228 | - * Assertion: ...only a reference to the <code>Collection</code> | |
229 | - * is copied, and not the contents | |
230 | 210 | */ |
231 | 211 | @TestTargetNew( |
232 | 212 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -248,7 +228,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
248 | 228 | |
249 | 229 | /** |
250 | 230 | * Test #1 for <code>toString()</code> method<br> |
251 | - * Assertion: returns the formatted string describing parameters | |
252 | 231 | */ |
253 | 232 | @TestTargetNew( |
254 | 233 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -265,7 +244,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
265 | 244 | |
266 | 245 | /** |
267 | 246 | * Test #2 for <code>toString()</code> method<br> |
268 | - * Assertion: returns the formatted string describing parameters | |
269 | 247 | */ |
270 | 248 | @TestTargetNew( |
271 | 249 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -284,7 +262,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
284 | 262 | |
285 | 263 | /** |
286 | 264 | * Test #1 for <code>getCollection()</code> method<br> |
287 | - * Assertion: returns the Collection (never null) | |
288 | 265 | */ |
289 | 266 | @TestTargetNew( |
290 | 267 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -299,7 +276,6 @@ public class CollectionCertStoreParametersTest extends TestCase { | ||
299 | 276 | |
300 | 277 | /** |
301 | 278 | * Test #2 for <code>getCollection()</code> method<br> |
302 | - * Assertion: returns the Collection (never null) | |
303 | 279 | */ |
304 | 280 | @TestTargetNew( |
305 | 281 | level = TestLevel.PARTIAL_COMPLETE, |
@@ -1,292 +0,0 @@ | ||
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 | -package tests.security.cert; | |
19 | - | |
20 | -import dalvik.annotation.TestTargets; | |
21 | -import dalvik.annotation.TestLevel; | |
22 | -import dalvik.annotation.TestTargetNew; | |
23 | -import dalvik.annotation.TestTargetClass; | |
24 | - | |
25 | -import junit.framework.TestCase; | |
26 | - | |
27 | -import java.security.cert.PolicyNode; | |
28 | -import java.security.cert.PolicyQualifierInfo; | |
29 | -import java.util.HashSet; | |
30 | -import java.util.Set; | |
31 | -import java.util.Iterator; | |
32 | - | |
33 | -import org.apache.harmony.security.tests.support.cert.PolicyNodeImpl; | |
34 | - | |
35 | -/** | |
36 | - * Tests for <code>java.security.cert.PolicyNode</code> fields and methods | |
37 | - * | |
38 | - */ | |
39 | -@TestTargetClass(PolicyNode.class) | |
40 | -public class PolicyNodeTest extends TestCase { | |
41 | - | |
42 | - private String validPolicy = "ValidPolicy"; | |
43 | - private String anyPolicy = "2.5.29.32.0"; | |
44 | - private boolean criticalityIndicator = true; | |
45 | - private HashSet hs = null; | |
46 | - | |
47 | - /** | |
48 | - * Returns valid DER encoding for the following ASN.1 definition | |
49 | - * (as specified in RFC 3280 - | |
50 | - * Internet X.509 Public Key Infrastructure. | |
51 | - * Certificate and Certificate Revocation List (CRL) Profile. | |
52 | - * http://www.ietf.org/rfc/rfc3280.txt): | |
53 | - * | |
54 | - * PolicyQualifierInfo ::= SEQUENCE { | |
55 | - * policyQualifierId PolicyQualifierId, | |
56 | - * qualifier ANY DEFINED BY policyQualifierId | |
57 | - * } | |
58 | - * | |
59 | - * where policyQualifierId (OID) is | |
60 | - * 1.3.6.1.5.5.7.2.1 | |
61 | - * and qualifier (IA5String) is | |
62 | - * "http://www.qq.com/stmt.txt" | |
63 | - * | |
64 | - * (data generated by own encoder during test development) | |
65 | - */ | |
66 | - private static final byte[] getDerEncoding() { | |
67 | - // DO NOT MODIFY! | |
68 | - return new byte[] { | |
69 | - (byte)0x30, (byte)0x26, // tag Seq, length | |
70 | - (byte)0x06, (byte)0x08, // tag OID, length | |
71 | - (byte)0x2b, (byte)0x06, (byte)0x01, (byte)0x05, // oid value | |
72 | - (byte)0x05, (byte)0x07, (byte)0x02, (byte)0x01, // oid value | |
73 | - (byte)0x16, (byte)0x1a, // tag IA5String, length | |
74 | - (byte)0x68, (byte)0x74, (byte)0x74, (byte)0x70, // IA5String value | |
75 | - (byte)0x3a, (byte)0x2f, (byte)0x2f, (byte)0x77, // IA5String value | |
76 | - (byte)0x77, (byte)0x77, (byte)0x2e, (byte)0x71, // IA5String value | |
77 | - (byte)0x71, (byte)0x2e, (byte)0x63, (byte)0x6f, // IA5String value | |
78 | - (byte)0x6d, (byte)0x2f, (byte)0x73, (byte)0x74, // IA5String value | |
79 | - (byte)0x6d, (byte)0x74, (byte)0x2e, (byte)0x74, // IA5String value | |
80 | - (byte)0x78, (byte)0x74 // IA5String value | |
81 | - }; | |
82 | - } | |
83 | - | |
84 | - protected void setUp() { | |
85 | - hs = new HashSet(); | |
86 | - hs.add(new String("StringParameter1")); | |
87 | - hs.add(new String("StringParameter2")); | |
88 | - hs.add(new String("StringParameter3")); | |
89 | - } | |
90 | - | |
91 | - protected void setUp1() { | |
92 | - hs = new HashSet(); | |
93 | - try { | |
94 | - hs.add(new PolicyQualifierInfo(getDerEncoding())); | |
95 | - } catch (Exception e) { | |
96 | - fail("Ezxception " + e + " for setUp1()"); | |
97 | - } | |
98 | - } | |
99 | - | |
100 | - | |
101 | - class MyPolicyNode extends PolicyNodeImpl { | |
102 | - MyPolicyNode(PolicyNodeImpl policynode, String s, Set set, | |
103 | - boolean flag, Set set1, boolean flag1) { | |
104 | - super(policynode, s, set, flag, set1, flag1); | |
105 | - } | |
106 | - } | |
107 | - | |
108 | - // | |
109 | - // Tests | |
110 | - // | |
111 | - | |
112 | - /** | |
113 | - * @tests java.security.cert.PolicyNode#getDepth() | |
114 | - */ | |
115 | - @TestTargetNew( | |
116 | - level = TestLevel.COMPLETE, | |
117 | - notes = "", | |
118 | - method = "getDepth", | |
119 | - args = {} | |
120 | - ) | |
121 | - public final void test_getDepth() { | |
122 | - MyPolicyNode pn = new MyPolicyNode(null, validPolicy, null, criticalityIndicator, null, true); | |
123 | - try { | |
124 | - assertEquals(pn.getDepth(), 0); | |
125 | - } catch (Exception e) { | |
126 | - fail("Unexpected exception: " + e); | |
127 | - } | |
128 | - MyPolicyNode pn1 = new MyPolicyNode(pn, validPolicy, null, criticalityIndicator, null, true); | |
129 | - try { | |
130 | - assertEquals(pn1.getDepth(), 1); | |
131 | - } catch (Exception e) { | |
132 | - fail("Unexpected exception: " + e); | |
133 | - } | |
134 | - } | |
135 | - | |
136 | - /** | |
137 | - * @tests java.security.cert.PolicyNode#getValidPolicy() | |
138 | - */ | |
139 | - @TestTargetNew( | |
140 | - level = TestLevel.COMPLETE, | |
141 | - notes = "", | |
142 | - method = "getValidPolicy", | |
143 | - args = {} | |
144 | - ) | |
145 | - public final void test_getValidPolicy() { | |
146 | - MyPolicyNode pn = new MyPolicyNode(null, null, null, criticalityIndicator, null, true); | |
147 | - try { | |
148 | - assertEquals(pn.getValidPolicy(), ""); | |
149 | - } catch (Exception e) { | |
150 | - fail("Unexpected exception: " + e); | |
151 | - } | |
152 | - pn = new MyPolicyNode(pn, validPolicy, null, criticalityIndicator, null, true); | |
153 | - try { | |
154 | - assertEquals(pn.getValidPolicy(), "ValidPolicy"); | |
155 | - } catch (Exception e) { | |
156 | - fail("Unexpected exception: " + e); | |
157 | - } | |
158 | - pn = new MyPolicyNode(pn, anyPolicy, null, criticalityIndicator, null, true); | |
159 | - try { | |
160 | - assertEquals(pn.getValidPolicy(), "2.5.29.32.0"); | |
161 | - } catch (Exception e) { | |
162 | - fail("Unexpected exception: " + e); | |
163 | - } | |
164 | - } | |
165 | - | |
166 | - /** | |
167 | - * @tests java.security.cert.PolicyNode#isCritical() | |
168 | - */ | |
169 | - @TestTargetNew( | |
170 | - level = TestLevel.COMPLETE, | |
171 | - notes = "", | |
172 | - method = "isCritical", | |
173 | - args = {} | |
174 | - ) | |
175 | - public final void test_isCritical() { | |
176 | - MyPolicyNode pn = new MyPolicyNode(null, anyPolicy, null, criticalityIndicator, null, true); | |
177 | - try { | |
178 | - assertEquals(pn.isCritical(), true); | |
179 | - } catch (Exception e) { | |
180 | - fail("Unexpected exception: " + e); | |
181 | - } | |
182 | - criticalityIndicator = false; | |
183 | - pn = new MyPolicyNode(null, validPolicy, null, criticalityIndicator, null, true); | |
184 | - try { | |
185 | - assertEquals(pn.isCritical(), false); | |
186 | - } catch (Exception e) { | |
187 | - fail("Unexpected exception: " + e); | |
188 | - } | |
189 | - } | |
190 | - | |
191 | - /** | |
192 | - * @tests java.security.cert.PolicyNode#getParent() | |
193 | - */ | |
194 | - @TestTargetNew( | |
195 | - level = TestLevel.COMPLETE, | |
196 | - notes = "", | |
197 | - method = "getParent", | |
198 | - args = {} | |
199 | - ) | |
200 | - public final void test_getParent() { | |
201 | - MyPolicyNode pn = new MyPolicyNode(null, anyPolicy, null, criticalityIndicator, null, true); | |
202 | - try { | |
203 | - assertNull(pn.getParent()); | |
204 | - assertEquals(pn.getDepth(), 0); | |
205 | - } catch (Exception e) { | |
206 | - fail("Unexpected exception: " + e); | |
207 | - } | |
208 | - MyPolicyNode pn1 = new MyPolicyNode(pn, anyPolicy, null, criticalityIndicator, null, true); | |
209 | - try { | |
210 | - PolicyNode newPN = pn1.getParent(); | |
211 | - assertEquals(newPN.getDepth(), 0); | |
212 | - } catch (Exception e) { | |
213 | - fail("Unexpected exception: " + e); | |
214 | - } | |
215 | - MyPolicyNode pn2 = new MyPolicyNode(pn1, anyPolicy, null, criticalityIndicator, null, true); | |
216 | - try { | |
217 | - PolicyNode newPN = pn2.getParent(); | |
218 | - assertEquals(newPN.getDepth(), 1); | |
219 | - } catch (Exception e) { | |
220 | - fail("Unexpected exception: " + e); | |
221 | - } | |
222 | - } | |
223 | - | |
224 | - /** | |
225 | - * @tests java.security.cert.PolicyNode#getExpectedPolicies() | |
226 | - */ | |
227 | - @TestTargetNew( | |
228 | - level = TestLevel.COMPLETE, | |
229 | - notes = "", | |
230 | - method = "getExpectedPolicies", | |
231 | - args = {} | |
232 | - ) | |
233 | - public final void test_getExpectedPolicies() { | |
234 | - setUp(); | |
235 | - MyPolicyNode pn = new MyPolicyNode(null, anyPolicy, null, criticalityIndicator, hs, true); | |
236 | - try { | |
237 | - Set res = pn.getExpectedPolicies(); | |
238 | - assertEquals(res.size(), hs.size()); | |
239 | - assertEquals(res, hs); | |
240 | - } catch (Exception e) { | |
241 | - fail("Unexpected exception: " + e); | |
242 | - } | |
243 | - } | |
244 | - | |
245 | - /** | |
246 | - * @tests java.security.cert.PolicyNode#getPolicyQualifiers() | |
247 | - */ | |
248 | - @TestTargetNew( | |
249 | - level = TestLevel.COMPLETE, | |
250 | - notes = "", | |
251 | - method = "getPolicyQualifiers", | |
252 | - args = {} | |
253 | - ) | |
254 | - public final void test_getPolicyQualifiers() { | |
255 | - setUp1(); | |
256 | - MyPolicyNode pn = new MyPolicyNode(null, anyPolicy, hs, criticalityIndicator, null, true); | |
257 | - try { | |
258 | - Set res = pn.getPolicyQualifiers(); | |
259 | - assertEquals(res.size(), hs.size()); | |
260 | - assertEquals(res, hs); | |
261 | - } catch (Exception e) { | |
262 | - fail("Unexpected exception: " + e); | |
263 | - } | |
264 | - } | |
265 | - | |
266 | - /** | |
267 | - * @tests java.security.cert.PolicyNode#getChildren() | |
268 | - */ | |
269 | - @TestTargetNew( | |
270 | - level = TestLevel.COMPLETE, | |
271 | - notes = "", | |
272 | - method = "getChildren", | |
273 | - args = {} | |
274 | - ) | |
275 | - public final void test_getChildren() { | |
276 | - MyPolicyNode pn = new MyPolicyNode(null, anyPolicy, null, criticalityIndicator, null, true); | |
277 | - Iterator it = pn.getChildren(); | |
278 | - try { | |
279 | - it.remove(); | |
280 | - fail("UnsupportedOperationException was not thrown"); | |
281 | - } catch (UnsupportedOperationException uoe) { | |
282 | - //expected | |
283 | - } | |
284 | - MyPolicyNode pn1 = new MyPolicyNode(pn, anyPolicy, null, criticalityIndicator, null, true); | |
285 | - try { | |
286 | - it = pn1.getChildren(); | |
287 | - assertFalse(it.hasNext()); | |
288 | - } catch (Exception e) { | |
289 | - fail("Unexpected exception: " + e); | |
290 | - } | |
291 | - } | |
292 | -} | |
\ No newline at end of file |
@@ -1,118 +0,0 @@ | ||
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 | -package org.apache.harmony.security.tests.support.acl; | |
19 | - | |
20 | -import java.security.Principal; | |
21 | -import java.security.acl.*; | |
22 | -import java.util.Enumeration; | |
23 | -import java.util.Vector; | |
24 | - | |
25 | -/** | |
26 | - * Additional class for verification AclEntry interface | |
27 | - */ | |
28 | -public class AclEntryImpl implements AclEntry { | |
29 | - | |
30 | - private Principal user; | |
31 | - private Vector permissionSet; | |
32 | - private boolean negative; | |
33 | - | |
34 | - public AclEntryImpl(Principal principal) { | |
35 | - user = null; | |
36 | - permissionSet = new Vector(10, 10); | |
37 | - negative = false; | |
38 | - user = principal; | |
39 | - } | |
40 | - | |
41 | - public AclEntryImpl() { | |
42 | - user = null; | |
43 | - permissionSet = new Vector(10, 10); | |
44 | - negative = false; | |
45 | - } | |
46 | - | |
47 | - public boolean setPrincipal(Principal principal) { | |
48 | - if(user != null) { | |
49 | - return false; | |
50 | - } else { | |
51 | - user = principal; | |
52 | - return true; | |
53 | - } | |
54 | - } | |
55 | - | |
56 | - public void setNegativePermissions() { | |
57 | - negative = true; | |
58 | - } | |
59 | - | |
60 | - public boolean isNegative() { | |
61 | - return negative; | |
62 | - } | |
63 | - | |
64 | - public boolean addPermission(Permission permission) { | |
65 | - if(permissionSet.contains(permission)) { | |
66 | - return false; | |
67 | - } else { | |
68 | - permissionSet.addElement(permission); | |
69 | - return true; | |
70 | - } | |
71 | - } | |
72 | - | |
73 | - public boolean removePermission(Permission permission) { | |
74 | - return permissionSet.removeElement(permission); | |
75 | - } | |
76 | - | |
77 | - public boolean checkPermission(Permission permission) { | |
78 | - return permissionSet.contains(permission); | |
79 | - } | |
80 | - | |
81 | - public Enumeration permissions() { | |
82 | - return permissionSet.elements(); | |
83 | - } | |
84 | - | |
85 | - public String toString() { | |
86 | - StringBuffer stringbuffer = new StringBuffer(); | |
87 | - if(negative) | |
88 | - stringbuffer.append("-"); | |
89 | - else | |
90 | - stringbuffer.append("+"); | |
91 | - if(user instanceof Group) | |
92 | - stringbuffer.append("Group."); | |
93 | - else | |
94 | - stringbuffer.append("User."); | |
95 | - stringbuffer.append((new StringBuilder()).append(user).append("=").toString()); | |
96 | - Enumeration enumeration = permissions(); | |
97 | - do { | |
98 | - if(!enumeration.hasMoreElements()) | |
99 | - break; | |
100 | - Permission permission = (Permission)enumeration.nextElement(); | |
101 | - stringbuffer.append(permission); | |
102 | - if(enumeration.hasMoreElements()) | |
103 | - stringbuffer.append(","); | |
104 | - } while(true); | |
105 | - return new String(stringbuffer); | |
106 | - } | |
107 | - | |
108 | - public synchronized Object clone() { | |
109 | - AclEntryImpl aclentryimpl = new AclEntryImpl(user); | |
110 | - aclentryimpl.permissionSet = (Vector)permissionSet.clone(); | |
111 | - aclentryimpl.negative = negative; | |
112 | - return aclentryimpl; | |
113 | - } | |
114 | - | |
115 | - public Principal getPrincipal() { | |
116 | - return user; | |
117 | - } | |
118 | -} | |
\ No newline at end of file |
@@ -1,51 +0,0 @@ | ||
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 | -package org.apache.harmony.security.tests.support.acl; | |
19 | - | |
20 | -import java.security.acl.Acl; | |
21 | -import java.util.*; | |
22 | - | |
23 | -final class AclEnumerator implements Enumeration { | |
24 | - | |
25 | - Acl acl; | |
26 | - Enumeration u1; | |
27 | - Enumeration u2; | |
28 | - Enumeration g1; | |
29 | - Enumeration g2; | |
30 | - | |
31 | - AclEnumerator(Acl acl1, Hashtable hashtable, Hashtable hashtable1, Hashtable hashtable2, Hashtable hashtable3) { | |
32 | - acl = acl1; | |
33 | - u1 = hashtable.elements(); | |
34 | - u2 = hashtable2.elements(); | |
35 | - g1 = hashtable1.elements(); | |
36 | - g2 = hashtable3.elements(); | |
37 | - } | |
38 | - | |
39 | - public boolean hasMoreElements() { | |
40 | - return u1.hasMoreElements() || u2.hasMoreElements() || g1.hasMoreElements() || g2.hasMoreElements(); | |
41 | - } | |
42 | - | |
43 | - public Object nextElement() { | |
44 | - Acl acl1 = acl; | |
45 | - if(u2.hasMoreElements()) return u2.nextElement(); | |
46 | - if(g1.hasMoreElements()) return g1.nextElement(); | |
47 | - if(u1.hasMoreElements()) return u1.nextElement(); | |
48 | - if(g2.hasMoreElements()) return g2.nextElement(); | |
49 | - return acl1; | |
50 | - } | |
51 | -} | |
\ No newline at end of file |
@@ -1,211 +0,0 @@ | ||
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 | -package org.apache.harmony.security.tests.support.acl; | |
19 | - | |
20 | -import java.security.Principal; | |
21 | -import java.security.acl.*; | |
22 | -import java.util.*; | |
23 | - | |
24 | -/** | |
25 | - * Additional class for verification Acl interface | |
26 | - */ | |
27 | -public class AclImpl extends OwnerImpl implements Acl { | |
28 | - | |
29 | - private Hashtable allowedUsersTable; | |
30 | - private Hashtable allowedGroupsTable; | |
31 | - private Hashtable deniedUsersTable; | |
32 | - private Hashtable deniedGroupsTable; | |
33 | - private String aclName; | |
34 | - private Vector zeroSet; | |
35 | - | |
36 | - public AclImpl(Principal principal, String s) { | |
37 | - super(principal); | |
38 | - allowedUsersTable = new Hashtable(23); | |
39 | - allowedGroupsTable = new Hashtable(23); | |
40 | - deniedUsersTable = new Hashtable(23); | |
41 | - deniedGroupsTable = new Hashtable(23); | |
42 | - aclName = null; | |
43 | - zeroSet = new Vector(1, 1); | |
44 | - try { | |
45 | - setName(principal, s); | |
46 | - } catch(Exception exception) { } | |
47 | - } | |
48 | - | |
49 | - public void setName(Principal principal, String s) | |
50 | - throws NotOwnerException { | |
51 | - if(!isOwner(principal)) { | |
52 | - throw new NotOwnerException(); | |
53 | - } else { | |
54 | - aclName = s; | |
55 | - return; | |
56 | - } | |
57 | - } | |
58 | - | |
59 | - public String getName() { | |
60 | - return aclName; | |
61 | - } | |
62 | - | |
63 | - public synchronized boolean addEntry(Principal principal, AclEntry aclentry) | |
64 | - throws NotOwnerException { | |
65 | - if(!isOwner(principal)) throw new NotOwnerException(); | |
66 | - Hashtable hashtable = findTable(aclentry); | |
67 | - Principal principal1 = aclentry.getPrincipal(); | |
68 | - if(hashtable.get(principal1) != null) { | |
69 | - return false; | |
70 | - } else { | |
71 | - hashtable.put(principal1, aclentry); | |
72 | - return true; | |
73 | - } | |
74 | - } | |
75 | - | |
76 | - public synchronized boolean removeEntry(Principal principal, AclEntry aclentry) | |
77 | - throws NotOwnerException { | |
78 | - if(!isOwner(principal)) { | |
79 | - throw new NotOwnerException(); | |
80 | - } else { | |
81 | - Hashtable hashtable = findTable(aclentry); | |
82 | - Principal principal1 = aclentry.getPrincipal(); | |
83 | - Object obj = hashtable.remove(principal1); | |
84 | - return obj != null; | |
85 | - } | |
86 | - } | |
87 | - | |
88 | - public synchronized Enumeration getPermissions(Principal principal) { | |
89 | - Enumeration enumeration2 = subtract(getGroupPositive(principal), getGroupNegative(principal)); | |
90 | - Enumeration enumeration3 = subtract(getGroupNegative(principal), getGroupPositive(principal)); | |
91 | - Enumeration enumeration = subtract(getIndividualPositive(principal), getIndividualNegative(principal)); | |
92 | - Enumeration enumeration1 = subtract(getIndividualNegative(principal), getIndividualPositive(principal)); | |
93 | - Enumeration enumeration4 = subtract(enumeration2, enumeration1); | |
94 | - Enumeration enumeration5 = union(enumeration, enumeration4); | |
95 | - enumeration = subtract(getIndividualPositive(principal), getIndividualNegative(principal)); | |
96 | - enumeration1 = subtract(getIndividualNegative(principal), getIndividualPositive(principal)); | |
97 | - enumeration4 = subtract(enumeration3, enumeration); | |
98 | - Enumeration enumeration6 = union(enumeration1, enumeration4); | |
99 | - return subtract(enumeration5, enumeration6); | |
100 | - } | |
101 | - | |
102 | - public boolean checkPermission(Principal principal, Permission permission) { | |
103 | - for(Enumeration enumeration = getPermissions(principal); enumeration.hasMoreElements();) { | |
104 | - Permission permission1 = (Permission)enumeration.nextElement(); | |
105 | - if(permission1.equals(permission)) | |
106 | - return true; | |
107 | - } | |
108 | - return false; | |
109 | - } | |
110 | - | |
111 | - public synchronized Enumeration entries() { | |
112 | - return new AclEnumerator(this, allowedUsersTable, allowedGroupsTable, deniedUsersTable, deniedGroupsTable); | |
113 | - } | |
114 | - | |
115 | - public String toString() { | |
116 | - StringBuffer stringbuffer = new StringBuffer(); | |
117 | - for(Enumeration enumeration = entries(); enumeration.hasMoreElements(); stringbuffer.append("\n")) { | |
118 | - AclEntry aclentry = (AclEntry)enumeration.nextElement(); | |
119 | - stringbuffer.append(aclentry.toString().trim()); | |
120 | - } | |
121 | - return stringbuffer.toString(); | |
122 | - } | |
123 | - | |
124 | - private Hashtable findTable(AclEntry aclentry) { | |
125 | - Hashtable hashtable = null; | |
126 | - Principal principal = aclentry.getPrincipal(); | |
127 | - if(principal instanceof Group) { | |
128 | - if(aclentry.isNegative()) | |
129 | - hashtable = deniedGroupsTable; | |
130 | - else | |
131 | - hashtable = allowedGroupsTable; | |
132 | - } else | |
133 | - if(aclentry.isNegative()) | |
134 | - hashtable = deniedUsersTable; | |
135 | - else | |
136 | - hashtable = allowedUsersTable; | |
137 | - return hashtable; | |
138 | - } | |
139 | - | |
140 | - private static Enumeration union(Enumeration enumeration, Enumeration enumeration1) { | |
141 | - Vector vector = new Vector(20, 20); | |
142 | - for(; enumeration.hasMoreElements(); vector.addElement(enumeration.nextElement())); | |
143 | - do { | |
144 | - if(!enumeration1.hasMoreElements()) | |
145 | - break; | |
146 | - Object obj = enumeration1.nextElement(); | |
147 | - if(!vector.contains(obj)) | |
148 | - vector.addElement(obj); | |
149 | - } while(true); | |
150 | - return vector.elements(); | |
151 | - } | |
152 | - | |
153 | - private Enumeration subtract(Enumeration enumeration, Enumeration enumeration1) { | |
154 | - Vector vector = new Vector(20, 20); | |
155 | - for(; enumeration.hasMoreElements(); vector.addElement(enumeration.nextElement())); | |
156 | - do { | |
157 | - if(!enumeration1.hasMoreElements()) | |
158 | - break; | |
159 | - Object obj = enumeration1.nextElement(); | |
160 | - if(vector.contains(obj)) | |
161 | - vector.removeElement(obj); | |
162 | - } while(true); | |
163 | - return vector.elements(); | |
164 | - } | |
165 | - | |
166 | - private Enumeration getGroupPositive(Principal principal) { | |
167 | - Enumeration enumeration = zeroSet.elements(); | |
168 | - Enumeration enumeration1 = allowedGroupsTable.keys(); | |
169 | - do { | |
170 | - if(!enumeration1.hasMoreElements()) | |
171 | - break; | |
172 | - Group group = (Group)enumeration1.nextElement(); | |
173 | - if(group.isMember(principal)) { | |
174 | - AclEntry aclentry = (AclEntry)allowedGroupsTable.get(group); | |
175 | - enumeration = union(aclentry.permissions(), enumeration); | |
176 | - } | |
177 | - } while(true); | |
178 | - return enumeration; | |
179 | - } | |
180 | - | |
181 | - private Enumeration getGroupNegative(Principal principal) { | |
182 | - Enumeration enumeration = zeroSet.elements(); | |
183 | - Enumeration enumeration1 = deniedGroupsTable.keys(); | |
184 | - do { | |
185 | - if(!enumeration1.hasMoreElements()) | |
186 | - break; | |
187 | - Group group = (Group)enumeration1.nextElement(); | |
188 | - if(group.isMember(principal)) { | |
189 | - AclEntry aclentry = (AclEntry)deniedGroupsTable.get(group); | |
190 | - enumeration = union(aclentry.permissions(), enumeration); | |
191 | - } | |
192 | - } while(true); | |
193 | - return enumeration; | |
194 | - } | |
195 | - | |
196 | - private Enumeration getIndividualPositive(Principal principal) { | |
197 | - Enumeration enumeration = zeroSet.elements(); | |
198 | - AclEntry aclentry = (AclEntry)allowedUsersTable.get(principal); | |
199 | - if(aclentry != null) | |
200 | - enumeration = aclentry.permissions(); | |
201 | - return enumeration; | |
202 | - } | |
203 | - | |
204 | - private Enumeration getIndividualNegative(Principal principal) { | |
205 | - Enumeration enumeration = zeroSet.elements(); | |
206 | - AclEntry aclentry = (AclEntry)deniedUsersTable.get(principal); | |
207 | - if(aclentry != null) | |
208 | - enumeration = aclentry.permissions(); | |
209 | - return enumeration; | |
210 | - } | |
211 | -} | |
\ No newline at end of file |
@@ -1,112 +0,0 @@ | ||
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 | -package org.apache.harmony.security.tests.support.acl; | |
19 | - | |
20 | -import java.security.Principal; | |
21 | -import java.security.acl.Group; | |
22 | -import java.util.Enumeration; | |
23 | -import java.util.Vector; | |
24 | - | |
25 | -/** | |
26 | - * Additional class for verification Group interface | |
27 | - */ | |
28 | -public class GroupImpl implements Group { | |
29 | - | |
30 | - private Vector groupMembers; | |
31 | - private String group; | |
32 | - | |
33 | - public GroupImpl(String s) { | |
34 | - groupMembers = new Vector(50, 100); | |
35 | - group = s; | |
36 | - } | |
37 | - | |
38 | - public boolean addMember(Principal principal) { | |
39 | - if(groupMembers.contains(principal)) | |
40 | - return false; | |
41 | - if(group.equals(principal.toString())) { | |
42 | - throw new IllegalArgumentException(); | |
43 | - } else { | |
44 | - groupMembers.addElement(principal); | |
45 | - return true; | |
46 | - } | |
47 | - } | |
48 | - | |
49 | - public boolean removeMember(Principal principal) { | |
50 | - return groupMembers.removeElement(principal); | |
51 | - } | |
52 | - | |
53 | - public Enumeration members() { | |
54 | - return groupMembers.elements(); | |
55 | - } | |
56 | - | |
57 | - public boolean equals(Object obj) { | |
58 | - if(this == obj) | |
59 | - return true; | |
60 | - if(!(obj instanceof Group)) { | |
61 | - return false; | |
62 | - } else { | |
63 | - Group group1 = (Group)obj; | |
64 | - return group.equals(group1.toString()); | |
65 | - } | |
66 | - } | |
67 | - | |
68 | - public boolean equals(Group group1) { | |
69 | - return equals(group1); | |
70 | - } | |
71 | - | |
72 | - public String toString() { | |
73 | - return group; | |
74 | - } | |
75 | - | |
76 | - public int hashCode() { | |
77 | - return group.hashCode(); | |
78 | - } | |
79 | - | |
80 | - public boolean isMember(Principal principal) { | |
81 | - if(groupMembers.contains(principal)) { | |
82 | - return true; | |
83 | - } else { | |
84 | - Vector vector = new Vector(10); | |
85 | - return isMemberRecurse(principal, vector); | |
86 | - } | |
87 | - } | |
88 | - | |
89 | - public String getName() { | |
90 | - return group; | |
91 | - } | |
92 | - | |
93 | - boolean isMemberRecurse(Principal principal, Vector vector) { | |
94 | - for(Enumeration enumeration = members(); enumeration.hasMoreElements();) { | |
95 | - boolean flag = false; | |
96 | - Principal principal1 = (Principal)enumeration.nextElement(); | |
97 | - if(principal1.equals(principal)) | |
98 | - return true; | |
99 | - if(principal1 instanceof GroupImpl) { | |
100 | - GroupImpl groupimpl = (GroupImpl)principal1; | |
101 | - vector.addElement(this); | |
102 | - if(!vector.contains(groupimpl)) | |
103 | - flag = groupimpl.isMemberRecurse(principal, vector); | |
104 | - } else if(principal1 instanceof Group) { | |
105 | - Group group1 = (Group)principal1; | |
106 | - if(!vector.contains(group1)) flag = group1.isMember(principal); | |
107 | - } | |
108 | - if(flag) return flag; | |
109 | - } | |
110 | - return false; | |
111 | - } | |
112 | -} | |
\ No newline at end of file |
@@ -1,69 +0,0 @@ | ||
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 | -package org.apache.harmony.security.tests.support.acl; | |
19 | - | |
20 | -import java.security.Principal; | |
21 | -import java.security.acl.*; | |
22 | -import java.util.Enumeration; | |
23 | - | |
24 | -/** | |
25 | - * Additional class for verification Owner interface | |
26 | - */ | |
27 | -public class OwnerImpl implements Owner { | |
28 | - | |
29 | - private Group ownerGroup; | |
30 | - | |
31 | - public OwnerImpl(Principal principal) { | |
32 | - ownerGroup = new GroupImpl("AclOwners"); | |
33 | - ownerGroup.addMember(principal); | |
34 | - } | |
35 | - | |
36 | - public synchronized boolean addOwner(Principal principal, Principal principal1) | |
37 | - throws NotOwnerException { | |
38 | - | |
39 | - if(!isOwner(principal)) | |
40 | - { | |
41 | - throw new NotOwnerException(); | |
42 | - } else { | |
43 | - if (ownerGroup.isMember(principal1)) return false; | |
44 | - if (!ownerGroup.isMember(principal1)) { | |
45 | - ownerGroup.addMember(principal1); | |
46 | - return true; | |
47 | - } | |
48 | - } | |
49 | - return false; | |
50 | - } | |
51 | - | |
52 | - public synchronized boolean deleteOwner(Principal principal, Principal principal1) | |
53 | - throws NotOwnerException, LastOwnerException { | |
54 | - | |
55 | - if(!isOwner(principal)) throw new NotOwnerException(); | |
56 | - Enumeration enumeration = ownerGroup.members(); | |
57 | - Object obj = enumeration.nextElement(); | |
58 | - if(enumeration.hasMoreElements()) { | |
59 | - return ownerGroup.removeMember(principal1); | |
60 | - } else { | |
61 | - throw new LastOwnerException(); | |
62 | - } | |
63 | - } | |
64 | - | |
65 | - public synchronized boolean isOwner(Principal principal) | |
66 | - { | |
67 | - return ownerGroup.isMember(principal); | |
68 | - } | |
69 | -} |
@@ -1,49 +0,0 @@ | ||
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 | -package org.apache.harmony.security.tests.support.acl; | |
19 | - | |
20 | -import java.security.acl.Permission; | |
21 | - | |
22 | -/** | |
23 | - * Additional class for verification Permission interface | |
24 | - */ | |
25 | -public class PermissionImpl implements Permission { | |
26 | - | |
27 | - private String permission; | |
28 | - | |
29 | - public PermissionImpl(String s) { | |
30 | - permission = s; | |
31 | - } | |
32 | - | |
33 | - public boolean equals(Object obj) { | |
34 | - if(obj instanceof Permission) { | |
35 | - Permission permission1 = (Permission)obj; | |
36 | - return permission.equals(permission1.toString()); | |
37 | - } else { | |
38 | - return false; | |
39 | - } | |
40 | - } | |
41 | - | |
42 | - public String toString() { | |
43 | - return permission; | |
44 | - } | |
45 | - | |
46 | -/* public int hashCode() { | |
47 | - return toString().hashCode(); | |
48 | - }*/ | |
49 | -} | |
\ No newline at end of file |
@@ -1,53 +0,0 @@ | ||
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 | -package org.apache.harmony.security.tests.support.acl; | |
19 | - | |
20 | -import java.security.Principal; | |
21 | - | |
22 | -/** | |
23 | - * Additional class for verification Principal interface | |
24 | - */ | |
25 | -public class PrincipalImpl implements Principal { | |
26 | - | |
27 | - private String user; | |
28 | - | |
29 | - public PrincipalImpl(String s) { | |
30 | - user = s; | |
31 | - } | |
32 | - | |
33 | - public boolean equals(Object obj) { | |
34 | - if(obj instanceof PrincipalImpl) { | |
35 | - PrincipalImpl principalimpl = (PrincipalImpl)obj; | |
36 | - return user.equals(principalimpl.toString()); | |
37 | - } else { | |
38 | - return false; | |
39 | - } | |
40 | - } | |
41 | - | |
42 | - public String toString() { | |
43 | - return user; | |
44 | - } | |
45 | - | |
46 | - public int hashCode() { | |
47 | - return user.hashCode(); | |
48 | - } | |
49 | - | |
50 | - public String getName() { | |
51 | - return user; | |
52 | - } | |
53 | -} |
@@ -1,256 +0,0 @@ | ||
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 | -package org.apache.harmony.security.tests.support.cert; | |
19 | - | |
20 | -import java.security.cert.PolicyNode; | |
21 | -import java.util.*; | |
22 | - | |
23 | -public class PolicyNodeImpl implements PolicyNode { | |
24 | - | |
25 | - private static final String ANY_POLICY = "2.5.29.32.0"; | |
26 | - private PolicyNodeImpl mParent; | |
27 | - private HashSet mChildren; | |
28 | - private String mValidPolicy; | |
29 | - private HashSet mQualifierSet; | |
30 | - private boolean mCriticalityIndicator; | |
31 | - private HashSet mExpectedPolicySet; | |
32 | - private boolean mOriginalExpectedPolicySet; | |
33 | - private int mDepth; | |
34 | - private boolean isImmutable; | |
35 | - | |
36 | - public PolicyNodeImpl(PolicyNodeImpl policynodeimpl, String s, Set set, | |
37 | - boolean flag, Set set1, boolean flag1) { | |
38 | - isImmutable = false; | |
39 | - mParent = policynodeimpl; | |
40 | - mChildren = new HashSet(); | |
41 | - if(s != null) { | |
42 | - mValidPolicy = s; | |
43 | - } else { | |
44 | - mValidPolicy = ""; | |
45 | - } | |
46 | - if(set != null) { | |
47 | - mQualifierSet = new HashSet(set); | |
48 | - } else { | |
49 | - mQualifierSet = new HashSet(); | |
50 | - } | |
51 | - mCriticalityIndicator = flag; | |
52 | - if(set1 != null) { | |
53 | - mExpectedPolicySet = new HashSet(set1); | |
54 | - } else { | |
55 | - mExpectedPolicySet = new HashSet(); | |
56 | - } | |
57 | - mOriginalExpectedPolicySet = !flag1; | |
58 | - if(mParent != null) { | |
59 | - mDepth = mParent.getDepth() + 1; | |
60 | - mParent.addChild(this); | |
61 | - } else { | |
62 | - mDepth = 0; | |
63 | - } | |
64 | - } | |
65 | - | |
66 | - PolicyNodeImpl(PolicyNodeImpl policynodeimpl, | |
67 | - PolicyNodeImpl policynodeimpl1) { | |
68 | - this(policynodeimpl, policynodeimpl1.mValidPolicy, ((Set) (policynodeimpl1.mQualifierSet)), policynodeimpl1.mCriticalityIndicator, ((Set) (policynodeimpl1.mExpectedPolicySet)), false); | |
69 | - } | |
70 | - | |
71 | - public PolicyNode getParent() { | |
72 | - return mParent; | |
73 | - } | |
74 | - | |
75 | - public Iterator getChildren() { | |
76 | - return Collections.unmodifiableSet(mChildren).iterator(); | |
77 | - } | |
78 | - | |
79 | - public int getDepth() { | |
80 | - return mDepth; | |
81 | - } | |
82 | - | |
83 | - public String getValidPolicy() { | |
84 | - return mValidPolicy; | |
85 | - } | |
86 | - | |
87 | - public Set getPolicyQualifiers() { | |
88 | - return Collections.unmodifiableSet(mQualifierSet); | |
89 | - } | |
90 | - | |
91 | - public Set getExpectedPolicies() { | |
92 | - return Collections.unmodifiableSet(mExpectedPolicySet); | |
93 | - } | |
94 | - | |
95 | - public boolean isCritical() { | |
96 | - return mCriticalityIndicator; | |
97 | - } | |
98 | - | |
99 | - public String toString() { | |
100 | - StringBuffer stringbuffer = new StringBuffer(asString()); | |
101 | - for(Iterator iterator = getChildren(); iterator.hasNext(); stringbuffer.append((PolicyNodeImpl)iterator.next())); | |
102 | - return stringbuffer.toString(); | |
103 | - } | |
104 | - | |
105 | - boolean isImmutable() { | |
106 | - return isImmutable; | |
107 | - } | |
108 | - | |
109 | - void setImmutable() { | |
110 | - if(isImmutable) return; | |
111 | - PolicyNodeImpl policynodeimpl; | |
112 | - for(Iterator iterator = mChildren.iterator(); iterator.hasNext(); policynodeimpl.setImmutable()) | |
113 | - policynodeimpl = (PolicyNodeImpl)iterator.next(); | |
114 | - | |
115 | - isImmutable = true; | |
116 | - } | |
117 | - | |
118 | - private void addChild(PolicyNodeImpl policynodeimpl) { | |
119 | - if(isImmutable) { | |
120 | - throw new IllegalStateException("PolicyNode is immutable"); | |
121 | - } else { | |
122 | - mChildren.add(policynodeimpl); | |
123 | - return; | |
124 | - } | |
125 | - } | |
126 | - | |
127 | - void addExpectedPolicy(String s) { | |
128 | - if(isImmutable) | |
129 | - throw new IllegalStateException("PolicyNode is immutable"); | |
130 | - if(mOriginalExpectedPolicySet) { | |
131 | - mExpectedPolicySet.clear(); | |
132 | - mOriginalExpectedPolicySet = false; | |
133 | - } | |
134 | - mExpectedPolicySet.add(s); | |
135 | - } | |
136 | - | |
137 | - void prune(int i) { | |
138 | - if(isImmutable) | |
139 | - throw new IllegalStateException("PolicyNode is immutable"); | |
140 | - if(mChildren.size() == 0) | |
141 | - return; | |
142 | - Iterator iterator = mChildren.iterator(); | |
143 | - do { | |
144 | - if(!iterator.hasNext()) break; | |
145 | - PolicyNodeImpl policynodeimpl = (PolicyNodeImpl)iterator.next(); | |
146 | - policynodeimpl.prune(i); | |
147 | - if(policynodeimpl.mChildren.size() == 0 && i > mDepth + 1) | |
148 | - iterator.remove(); | |
149 | - } while(true); | |
150 | - } | |
151 | - | |
152 | - void deleteChild(PolicyNode policynode) { | |
153 | - if(isImmutable) { | |
154 | - throw new IllegalStateException("PolicyNode is immutable"); | |
155 | - } else { | |
156 | - mChildren.remove(policynode); | |
157 | - return; | |
158 | - } | |
159 | - } | |
160 | - | |
161 | - PolicyNodeImpl copyTree() { | |
162 | - return copyTree(null); | |
163 | - } | |
164 | - | |
165 | - private PolicyNodeImpl copyTree(PolicyNodeImpl policynodeimpl) { | |
166 | - PolicyNodeImpl policynodeimpl1 = new PolicyNodeImpl(policynodeimpl, this); | |
167 | - PolicyNodeImpl policynodeimpl2; | |
168 | - for(Iterator iterator = mChildren.iterator(); iterator.hasNext(); policynodeimpl2.copyTree(policynodeimpl1)) | |
169 | - policynodeimpl2 = (PolicyNodeImpl)iterator.next(); | |
170 | - | |
171 | - return policynodeimpl1; | |
172 | - } | |
173 | - | |
174 | - Set getPolicyNodes(int i) { | |
175 | - HashSet hashset = new HashSet(); | |
176 | - getPolicyNodes(i, ((Set) (hashset))); | |
177 | - return hashset; | |
178 | - } | |
179 | - | |
180 | - private void getPolicyNodes(int i, Set set) { | |
181 | - if(mDepth == i) { | |
182 | - set.add(this); | |
183 | - } else { | |
184 | - PolicyNodeImpl policynodeimpl; | |
185 | - for(Iterator iterator = mChildren.iterator(); iterator.hasNext(); policynodeimpl.getPolicyNodes(i, set)) | |
186 | - policynodeimpl = (PolicyNodeImpl)iterator.next(); | |
187 | - } | |
188 | - } | |
189 | - | |
190 | - Set getPolicyNodesExpected(int i, String s, boolean flag) { | |
191 | - if(s.equals("2.5.29.32.0")) | |
192 | - return getPolicyNodes(i); | |
193 | - else | |
194 | - return getPolicyNodesExpectedHelper(i, s, flag); | |
195 | - } | |
196 | - | |
197 | - private Set getPolicyNodesExpectedHelper(int i, String s, boolean flag) { | |
198 | - HashSet hashset = new HashSet(); | |
199 | - if(mDepth < i) { | |
200 | - PolicyNodeImpl policynodeimpl; | |
201 | - for(Iterator iterator = mChildren.iterator(); iterator.hasNext(); hashset.addAll(policynodeimpl.getPolicyNodesExpectedHelper(i, s, flag))) | |
202 | - policynodeimpl = (PolicyNodeImpl)iterator.next(); | |
203 | - | |
204 | - } else if(flag) { | |
205 | - if(mExpectedPolicySet.contains("2.5.29.32.0")) | |
206 | - hashset.add(this); | |
207 | - } else if(mExpectedPolicySet.contains(s)) { | |
208 | - hashset.add(this); | |
209 | - } | |
210 | - return hashset; | |
211 | - } | |
212 | - | |
213 | - Set getPolicyNodesValid(int i, String s) { | |
214 | - HashSet hashset = new HashSet(); | |
215 | - if(mDepth < i) { | |
216 | - PolicyNodeImpl policynodeimpl; | |
217 | - for(Iterator iterator = mChildren.iterator(); iterator.hasNext(); hashset.addAll(policynodeimpl.getPolicyNodesValid(i, s))) | |
218 | - policynodeimpl = (PolicyNodeImpl)iterator.next(); | |
219 | - | |
220 | - } else if(mValidPolicy.equals(s)) { | |
221 | - hashset.add(this); | |
222 | - } | |
223 | - return hashset; | |
224 | - } | |
225 | - | |
226 | - private static String policyToString(String s) { | |
227 | - if(s.equals("2.5.29.32.0")) { | |
228 | - return "anyPolicy"; | |
229 | - } else { | |
230 | - return s; | |
231 | - } | |
232 | - } | |
233 | - | |
234 | - String asString() { | |
235 | - if(mParent == null) | |
236 | - return "anyPolicy ROOT\n"; | |
237 | - StringBuffer stringbuffer = new StringBuffer(); | |
238 | - int i = 0; | |
239 | - for(int j = getDepth(); i < j; i++) | |
240 | - stringbuffer.append(" "); | |
241 | - | |
242 | - stringbuffer.append(policyToString(getValidPolicy())); | |
243 | - stringbuffer.append(" CRIT: "); | |
244 | - stringbuffer.append(isCritical()); | |
245 | - stringbuffer.append(" EP: "); | |
246 | - for(Iterator iterator = getExpectedPolicies().iterator(); iterator.hasNext(); stringbuffer.append(" ")) { | |
247 | - String s = (String)iterator.next(); | |
248 | - stringbuffer.append(policyToString(s)); | |
249 | - } | |
250 | - | |
251 | - stringbuffer.append(" ("); | |
252 | - stringbuffer.append(getDepth()); | |
253 | - stringbuffer.append(")\n"); | |
254 | - return stringbuffer.toString(); | |
255 | - } | |
256 | -} |
@@ -153,7 +153,7 @@ public class NumberFormatTest extends TestCase { | ||
153 | 153 | Locale chLocale = new Locale("de", "CH"); |
154 | 154 | // END android-added |
155 | 155 | |
156 | - Locale[] requiredLocales = {usLocale, chLocale}; | |
156 | + Locale[] requiredLocales = {usLocale, arLocale, chLocale}; | |
157 | 157 | if (!Support_Locale.areLocalesAvailable(requiredLocales)) { |
158 | 158 | // locale dependent test, bug 1943269 |
159 | 159 | return; |
@@ -324,10 +324,38 @@ static void enableDebugFeatures(u4 debugFlags) | ||
324 | 324 | #endif |
325 | 325 | } |
326 | 326 | |
327 | -/* | |
327 | +/* | |
328 | + * Set Linux capability flags. | |
329 | + * | |
330 | + * Returns 0 on success, errno on failure. | |
331 | + */ | |
332 | +static int setCapabilities(int64_t permitted, int64_t effective) | |
333 | +{ | |
334 | +#ifdef HAVE_ANDROID_OS | |
335 | + struct __user_cap_header_struct capheader; | |
336 | + struct __user_cap_data_struct capdata; | |
337 | + | |
338 | + memset(&capheader, 0, sizeof(capheader)); | |
339 | + memset(&capdata, 0, sizeof(capdata)); | |
340 | + | |
341 | + capheader.version = _LINUX_CAPABILITY_VERSION; | |
342 | + capheader.pid = 0; | |
343 | + | |
344 | + capdata.effective = effective; | |
345 | + capdata.permitted = permitted; | |
346 | + | |
347 | + LOGV("CAPSET perm=%llx eff=%llx\n", permitted, effective); | |
348 | + if (capset(&capheader, &capdata) != 0) | |
349 | + return errno; | |
350 | +#endif /*HAVE_ANDROID_OS*/ | |
351 | + | |
352 | + return 0; | |
353 | +} | |
354 | + | |
355 | +/* | |
328 | 356 | * Utility routine to fork zygote and specialize the child process. |
329 | 357 | */ |
330 | -static pid_t forkAndSpecializeCommon(const u4* args) | |
358 | +static pid_t forkAndSpecializeCommon(const u4* args, bool isSystemServer) | |
331 | 359 | { |
332 | 360 | pid_t pid; |
333 | 361 |
@@ -336,6 +364,21 @@ static pid_t forkAndSpecializeCommon(const u4* args) | ||
336 | 364 | ArrayObject* gids = (ArrayObject *)args[2]; |
337 | 365 | u4 debugFlags = args[3]; |
338 | 366 | ArrayObject *rlimits = (ArrayObject *)args[4]; |
367 | + int64_t permittedCapabilities, effectiveCapabilities; | |
368 | + | |
369 | + if (isSystemServer) { | |
370 | + /* | |
371 | + * Don't use GET_ARG_LONG here for now. gcc is generating code | |
372 | + * that uses register d8 as a temporary, and that's coming out | |
373 | + * scrambled in the child process. b/3138621 | |
374 | + */ | |
375 | + //permittedCapabilities = GET_ARG_LONG(args, 5); | |
376 | + //effectiveCapabilities = GET_ARG_LONG(args, 7); | |
377 | + permittedCapabilities = args[5] | (int64_t) args[6] << 32; | |
378 | + effectiveCapabilities = args[7] | (int64_t) args[8] << 32; | |
379 | + } else { | |
380 | + permittedCapabilities = effectiveCapabilities = 0; | |
381 | + } | |
339 | 382 | |
340 | 383 | if (!gDvm.zygote) { |
341 | 384 | dvmThrowException("Ljava/lang/IllegalStateException;", |
@@ -367,7 +410,8 @@ static pid_t forkAndSpecializeCommon(const u4* args) | ||
367 | 410 | err = prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0); |
368 | 411 | |
369 | 412 | if (err < 0) { |
370 | - LOGW("cannot PR_SET_KEEPCAPS errno: %d", errno); | |
413 | + LOGE("cannot PR_SET_KEEPCAPS: %s", strerror(errno)); | |
414 | + dvmAbort(); | |
371 | 415 | } |
372 | 416 | } |
373 | 417 |
@@ -376,23 +420,34 @@ static pid_t forkAndSpecializeCommon(const u4* args) | ||
376 | 420 | err = setgroupsIntarray(gids); |
377 | 421 | |
378 | 422 | if (err < 0) { |
379 | - LOGW("cannot setgroups() errno: %d", errno); | |
423 | + LOGE("cannot setgroups(): %s", strerror(errno)); | |
424 | + dvmAbort(); | |
380 | 425 | } |
381 | 426 | |
382 | 427 | err = setrlimitsFromArray(rlimits); |
383 | 428 | |
384 | 429 | if (err < 0) { |
385 | - LOGW("cannot setrlimit() errno: %d", errno); | |
430 | + LOGE("cannot setrlimit(): %s", strerror(errno)); | |
431 | + dvmAbort(); | |
386 | 432 | } |
387 | 433 | |
388 | 434 | err = setgid(gid); |
389 | 435 | if (err < 0) { |
390 | - LOGW("cannot setgid(%d) errno: %d", gid, errno); | |
436 | + LOGE("cannot setgid(%d): %s", gid, strerror(errno)); | |
437 | + dvmAbort(); | |
391 | 438 | } |
392 | 439 | |
393 | 440 | err = setuid(uid); |
394 | 441 | if (err < 0) { |
395 | - LOGW("cannot setuid(%d) errno: %d", uid, errno); | |
442 | + LOGE("cannot setuid(%d): %s", uid, strerror(errno)); | |
443 | + dvmAbort(); | |
444 | + } | |
445 | + | |
446 | + err = setCapabilities(permittedCapabilities, effectiveCapabilities); | |
447 | + if (err != 0) { | |
448 | + LOGE("cannot set capabilities (%llx,%llx): %s\n", | |
449 | + permittedCapabilities, effectiveCapabilities, strerror(err)); | |
450 | + dvmAbort(); | |
396 | 451 | } |
397 | 452 | |
398 | 453 | /* |
@@ -425,19 +480,20 @@ static void Dalvik_dalvik_system_Zygote_forkAndSpecialize(const u4* args, | ||
425 | 480 | { |
426 | 481 | pid_t pid; |
427 | 482 | |
428 | - pid = forkAndSpecializeCommon(args); | |
483 | + pid = forkAndSpecializeCommon(args, false); | |
429 | 484 | |
430 | 485 | RETURN_INT(pid); |
431 | 486 | } |
432 | 487 | |
433 | -/* native public static int forkSystemServer(int uid, int gid, | |
434 | - * int[] gids, int debugFlags); | |
488 | +/* native public static int forkSystemServer(int uid, int gid, | |
489 | + * int[] gids, int debugFlags, long permittedCapabilities, | |
490 | + * long effectiveCapabilities); | |
435 | 491 | */ |
436 | 492 | static void Dalvik_dalvik_system_Zygote_forkSystemServer( |
437 | 493 | const u4* args, JValue* pResult) |
438 | 494 | { |
439 | 495 | pid_t pid; |
440 | - pid = forkAndSpecializeCommon(args); | |
496 | + pid = forkAndSpecializeCommon(args, true); | |
441 | 497 | |
442 | 498 | /* The zygote process checks whether the child process has died or not. */ |
443 | 499 | if (pid > 0) { |
@@ -462,7 +518,7 @@ const DalvikNativeMethod dvm_dalvik_system_Zygote[] = { | ||
462 | 518 | Dalvik_dalvik_system_Zygote_fork }, |
463 | 519 | { "forkAndSpecialize", "(II[II[[I)I", |
464 | 520 | Dalvik_dalvik_system_Zygote_forkAndSpecialize }, |
465 | - { "forkSystemServer", "(II[II[[I)I", | |
521 | + { "forkSystemServer", "(II[II[[IJJ)I", | |
466 | 522 | Dalvik_dalvik_system_Zygote_forkSystemServer }, |
467 | 523 | { NULL, NULL, NULL }, |
468 | 524 | }; |