/libcore/support/src/test/java/org/apache/harmony/security/tests/support/ |
H A D | TestUtils.java | 52 String tail = Integer.toHexString(0x000000ff & data[i]); 53 if (tail.length() == 1) { 54 tail = "0" + tail; 56 System.out.print(prefix + "0x" + tail + delimiter);
|
/libcore/ojluni/src/main/java/java/util/ |
H A D | ArrayDeque.java | 95 * thus avoiding head and tail wrapping around to equal each 104 * arbitrary number equal to tail if the deque is empty. 109 * The index at which the next element would be added to the tail 112 transient int tail; field in class:ArrayDeque 148 * when head and tail have wrapped around to become equal. 151 assert head == tail; 163 tail = n; 213 if (head == tail) 228 elements[tail] = e; 229 if ( (tail [all...] |
/libcore/ojluni/src/main/java/java/lang/ref/ |
H A D | ReferenceQueue.java | 47 private Reference<? extends T> tail = null; field in class:ReferenceQueue 83 if (tail == null) { 86 tail.queueNext = r; 88 tail = r; 89 tail.queueNext = r; 124 if (head == tail) { 125 tail = null;
|
/libcore/luni/src/main/java/java/util/concurrent/ |
H A D | ConcurrentLinkedQueue.java | 29 * The <em>tail</em> of the queue is that element that has been on the 31 * are inserted at the tail of the queue, and the queue retrieval 97 * reached in O(1) time from tail, but tail is merely an 121 * Both head and tail are permitted to lag. In fact, failing to 125 * that is, we update head/tail when the current pointer appears 128 * Since head and tail are updated concurrently and independently, 129 * it is possible for tail to lag behind head (why not)? 144 * Both head and tail may or may not point to a Node with a 146 * be null. Upon creation, both head and tail refe 205 private transient volatile Node<E> tail; field in class:ConcurrentLinkedQueue [all...] |
H A D | SynchronousQueue.java | 121 * cancelled. But if it may be pinned as the current tail, it must 568 transient volatile QNode tail; field in class:SynchronousQueue.TransferQueue 579 tail = h; 593 * Tries to cas nt as new tail. 596 if (tail == t) 626 * advance head and tail on behalf of other stalled/slow 630 * seeing uninitialized head or tail values. This never 642 QNode t = tail; 649 if (t != tail) // inconsistent read 651 if (tn != null) { // lagging tail [all...] |
H A D | ConcurrentLinkedDeque.java | 119 * The deque object has two node references, "head" and "tail". 120 * The head and tail are only approximations to the first and last 122 * following prev pointers from head; likewise for tail. However, 123 * it is permissible for head and tail to be referring to deleted 155 * head or tail. 174 * the nodes pointed at by head/tail never get gc-unlinked, since 175 * head/tail are needed to get "back on track" by other nodes that 198 * restart traversal from tail. 232 * - head may not be reachable from the first or last node, or from tail 240 * - the last node is always O(1) reachable from tail vi 248 private transient volatile Node<E> tail; field in class:ConcurrentLinkedDeque [all...] |
H A D | LinkedTransferQueue.java | 29 * producer. The <em>tail</em> of the queue is that element that has 85 * (unmatched) queue node (or null if empty); and "tail" that 90 * head tail 97 * tail pointers. This has led to the development of 133 * updates on head/tail fields. 136 * never versus always updating queue (head and tail) pointers. 143 * head tail 150 * similarly for "tail") is an empirical matter. We have found 157 * virtue of only sometimes updating head or tail pointers when 182 * known first unmatched node, and similarly for tail 534 private transient volatile Node tail; field in class:LinkedTransferQueue [all...] |
/libcore/luni/src/main/java/java/util/concurrent/locks/ |
H A D | AbstractQueuedLongSynchronizer.java | 63 private transient volatile Node tail; field in class:AbstractQueuedLongSynchronizer 121 Node oldTail = tail; 144 Node oldTail = tail; 188 * traverse backwards from tail to find the actual 194 for (Node p = tail; p != node && p != null; p = p.prev) 221 if (h != null && h != tail) { 301 // If we are the tail, remove ourselves. 302 if (node == tail && compareAndSetTail(node, pred)) { 891 return head != tail; 920 return (head == tail) [all...] |
H A D | AbstractQueuedSynchronizer.java | 292 * tail. To dequeue, you just set the head field. 295 * head | | <---- | | <---- | | tail 300 * operation on "tail", so there is a simple atomic point of 321 * updated "tail" when a node's successor appears to be null. 336 * is constructed and head and tail pointers are set upon first 427 * to be null, we can scan prev's from the tail to 532 private transient volatile Node tail; field in class:AbstractQueuedSynchronizer 588 Node oldTail = tail; 611 Node oldTail = tail; 655 * traverse backwards from tail t [all...] |
/libcore/luni/src/test/java/libcore/java/util/ |
H A D | OldTreeMapTest.java | 454 Map tail = tm.tailMap(objArray[900].toString()); 455 assertTrue("Returned map of incorrect size : " + tail.size(), tail 458 assertTrue("Map contains incorrect entries", tail 486 assertTrue(tail instanceof Serializable);
|
/libcore/support/src/test/java/tests/resources/x509/ |
H A D | create.sh | 31 SIG_OFFSET=$(openssl asn1parse -in "$DIR/cert-rsa.der" -inform d | tail -1 | cut -f1 -d:) 103 SIG_OFFSET=$(openssl asn1parse -in "$DIR/crl-rsa.der" -inform d | tail -1 | cut -f1 -d:)
|
/libcore/harmony-tests/src/test/java/org/apache/harmony/tests/java/util/ |
H A D | ControlTest.java | 378 String tail = src.getFile().split("hyts_resource")[1]; 383 String copyName = tmpdir + File.separator + "hyts_resource_copy" + tail;
|
H A D | TreeMapTest.java | 618 Map tail = tm.tailMap(objArray[900].toString()); 619 assertTrue("Returned map of incorrect size : " + tail.size(), tail 622 assertTrue("Map contains incorrect entries", tail 627 assertTrue(tail instanceof Serializable); 1709 // tail map of tail map
|