Expose new java.util APIs
Bug: 320460092
Test: atest CtsLibcoreOjTestCases:test.java.util.SequencedCollection
Test: atest CtsLibcoreOjTestCases:test.java.util
Test: atest CtsLibcoreTestCases:libcore.java.util.HashMapTest CtsLibcoreTestCases:libcore.java.util.HashSetTest CtsLibcoreTestCases:libcore.java.util.CollectionsTest
Change-Id: Id413d3b8bf78f3a767f19b834e3512344f898673
diff --git a/api/current.txt b/api/current.txt
index 0fa682f..ea120e2 100644
--- a/api/current.txt
+++ b/api/current.txt
@@ -13080,11 +13080,17 @@
ctor public ArrayList(int);
ctor public ArrayList();
ctor public ArrayList(@NonNull java.util.Collection<? extends E>);
+ method @FlaggedApi("com.android.libcore.v_apis") public void addFirst(E);
+ method @FlaggedApi("com.android.libcore.v_apis") public void addLast(E);
method @NonNull public Object clone();
method public void ensureCapacity(int);
method public void forEach(@NonNull java.util.function.Consumer<? super E>);
method public E get(int);
+ method @FlaggedApi("com.android.libcore.v_apis") public E getFirst();
+ method @FlaggedApi("com.android.libcore.v_apis") public E getLast();
+ method @FlaggedApi("com.android.libcore.v_apis") public E removeFirst();
method public boolean removeIf(@NonNull java.util.function.Predicate<? super E>);
+ method @FlaggedApi("com.android.libcore.v_apis") public E removeLast();
method public void replaceAll(@NonNull java.util.function.UnaryOperator<E>);
method public int size();
method public void sort(@Nullable java.util.Comparator<? super E>);
@@ -13570,6 +13576,7 @@
method public static void rotate(@NonNull java.util.List<?>, int);
method public static void shuffle(@NonNull java.util.List<?>);
method public static void shuffle(@NonNull java.util.List<?>, @NonNull java.util.Random);
+ method @FlaggedApi("com.android.libcore.v_apis") public static void shuffle(@NonNull java.util.List<?>, @NonNull java.util.random.RandomGenerator);
method @NonNull public static <T> java.util.Set<T> singleton(T);
method @NonNull public static <T> java.util.List<T> singletonList(T);
method @NonNull public static <K, V> java.util.Map<K,V> singletonMap(K, V);
@@ -13674,7 +13681,8 @@
method @Deprecated public String toLocaleString();
}
- public interface Deque<E> extends java.util.Queue<E> {
+ public interface Deque<E> extends java.util.Queue<E> java.util.SequencedCollection<E> {
+ method @FlaggedApi("com.android.libcore.v_apis") public boolean add(E);
method public void addFirst(E);
method public void addLast(E);
method @NonNull public java.util.Iterator<E> descendingIterator();
@@ -13692,6 +13700,7 @@
method public boolean removeFirstOccurrence(@Nullable Object);
method public E removeLast();
method public boolean removeLastOccurrence(@Nullable Object);
+ method @FlaggedApi("com.android.libcore.v_apis") @NonNull public default java.util.Deque<E> reversed();
}
public abstract class Dictionary<K, V> {
@@ -13862,6 +13871,7 @@
method public void forEach(@NonNull java.util.function.BiConsumer<? super K,? super V>);
method @Nullable public V getOrDefault(@Nullable Object, @Nullable V);
method @Nullable public V merge(K, @NonNull V, @NonNull java.util.function.BiFunction<? super V,? super V,? extends V>);
+ method @FlaggedApi("com.android.libcore.v_apis") @NonNull public static <K, V> java.util.HashMap<K,V> newHashMap(int);
method @Nullable public V putIfAbsent(K, V);
method public boolean remove(@Nullable Object, @Nullable Object);
method public boolean replace(K, @Nullable V, V);
@@ -13876,6 +13886,7 @@
ctor public HashSet(int);
method @NonNull public Object clone();
method @NonNull public java.util.Iterator<E> iterator();
+ method @FlaggedApi("com.android.libcore.v_apis") @NonNull public static <T> java.util.HashSet<T> newHashSet(int);
method public int size();
method @NonNull public java.util.Spliterator<E> spliterator();
}
@@ -14028,20 +14039,35 @@
method public default void remove();
}
- public class LinkedHashMap<K, V> extends java.util.HashMap<K,V> implements java.util.Map<K,V> {
+ public class LinkedHashMap<K, V> extends java.util.HashMap<K,V> implements java.util.Map<K,V> java.util.SequencedMap<K,V> {
ctor public LinkedHashMap(int, float);
ctor public LinkedHashMap(int);
ctor public LinkedHashMap();
ctor public LinkedHashMap(java.util.Map<? extends K,? extends V>);
ctor public LinkedHashMap(int, float, boolean);
+ method @FlaggedApi("com.android.libcore.v_apis") public static <K, V> java.util.LinkedHashMap<K,V> newLinkedHashMap(int);
+ method @FlaggedApi("com.android.libcore.v_apis") public V putFirst(K, V);
+ method @FlaggedApi("com.android.libcore.v_apis") public V putLast(K, V);
method protected boolean removeEldestEntry(java.util.Map.Entry<K,V>);
+ method @FlaggedApi("com.android.libcore.v_apis") public java.util.SequencedMap<K,V> reversed();
+ method @FlaggedApi("com.android.libcore.v_apis") public java.util.SequencedSet<java.util.Map.Entry<K,V>> sequencedEntrySet();
+ method @FlaggedApi("com.android.libcore.v_apis") public java.util.SequencedSet<K> sequencedKeySet();
+ method @FlaggedApi("com.android.libcore.v_apis") public java.util.SequencedCollection<V> sequencedValues();
}
- public class LinkedHashSet<E> extends java.util.HashSet<E> implements java.lang.Cloneable java.io.Serializable java.util.Set<E> {
+ public class LinkedHashSet<E> extends java.util.HashSet<E> implements java.lang.Cloneable java.util.SequencedSet<E> java.io.Serializable java.util.Set<E> {
ctor public LinkedHashSet(int, float);
ctor public LinkedHashSet(int);
ctor public LinkedHashSet();
ctor public LinkedHashSet(java.util.Collection<? extends E>);
+ method @FlaggedApi("com.android.libcore.v_apis") public void addFirst(E);
+ method @FlaggedApi("com.android.libcore.v_apis") public void addLast(E);
+ method @FlaggedApi("com.android.libcore.v_apis") public E getFirst();
+ method @FlaggedApi("com.android.libcore.v_apis") public E getLast();
+ method @FlaggedApi("com.android.libcore.v_apis") public static <T> java.util.LinkedHashSet<T> newLinkedHashSet(int);
+ method @FlaggedApi("com.android.libcore.v_apis") public E removeFirst();
+ method @FlaggedApi("com.android.libcore.v_apis") public E removeLast();
+ method @FlaggedApi("com.android.libcore.v_apis") public java.util.SequencedSet<E> reversed();
}
public class LinkedList<E> extends java.util.AbstractSequentialList<E> implements java.lang.Cloneable java.util.Deque<E> java.util.List<E> java.io.Serializable {
@@ -14071,11 +14097,12 @@
method public boolean removeFirstOccurrence(@Nullable Object);
method public E removeLast();
method public boolean removeLastOccurrence(@Nullable Object);
+ method @FlaggedApi("com.android.libcore.v_apis") @NonNull public java.util.LinkedList<E> reversed();
method public int size();
method @NonNull public java.util.Spliterator<E> spliterator();
}
- public interface List<E> extends java.util.Collection<E> {
+ public interface List<E> extends java.util.SequencedCollection<E> java.util.Collection<E> {
method public void add(int, E);
method public boolean addAll(int, @NonNull java.util.Collection<? extends E>);
method @NonNull public static <E> java.util.List<E> copyOf(@NonNull java.util.Collection<? extends E>);
@@ -14098,6 +14125,7 @@
method @NonNull @java.lang.SafeVarargs public static <E> java.util.List<E> of(@NonNull E...);
method public E remove(int);
method public default void replaceAll(@NonNull java.util.function.UnaryOperator<E>);
+ method @FlaggedApi("com.android.libcore.v_apis") @NonNull public default java.util.List<E> reversed();
method public E set(int, E);
method public default void sort(@Nullable java.util.Comparator<? super E>);
method @NonNull public java.util.List<E> subList(int, int);
@@ -14339,6 +14367,7 @@
method @NonNull public java.util.NavigableSet<K> navigableKeySet();
method @Nullable public java.util.Map.Entry<K,V> pollFirstEntry();
method @Nullable public java.util.Map.Entry<K,V> pollLastEntry();
+ method @FlaggedApi("com.android.libcore.v_apis") @NonNull public default java.util.NavigableMap<K,V> reversed();
method @NonNull public java.util.NavigableMap<K,V> subMap(K, boolean, K, boolean);
method @NonNull public java.util.NavigableMap<K,V> tailMap(K, boolean);
}
@@ -14350,9 +14379,11 @@
method public E floor(E);
method public java.util.NavigableSet<E> headSet(E, boolean);
method public E higher(E);
+ method @FlaggedApi("com.android.libcore.v_apis") public java.util.Iterator<E> iterator();
method public E lower(E);
method public E pollFirst();
method public E pollLast();
+ method @FlaggedApi("com.android.libcore.v_apis") public default java.util.NavigableSet<E> reversed();
method public java.util.NavigableSet<E> subSet(E, boolean, E, boolean);
method public java.util.NavigableSet<E> tailSet(E, boolean);
}
@@ -14721,6 +14752,33 @@
method public java.util.Scanner useRadix(int);
}
+ @FlaggedApi("com.android.libcore.v_apis") public interface SequencedCollection<E> extends java.util.Collection<E> {
+ method @FlaggedApi("com.android.libcore.v_apis") public default void addFirst(E);
+ method @FlaggedApi("com.android.libcore.v_apis") public default void addLast(E);
+ method @FlaggedApi("com.android.libcore.v_apis") public default E getFirst();
+ method @FlaggedApi("com.android.libcore.v_apis") public default E getLast();
+ method @FlaggedApi("com.android.libcore.v_apis") public default E removeFirst();
+ method @FlaggedApi("com.android.libcore.v_apis") public default E removeLast();
+ method @FlaggedApi("com.android.libcore.v_apis") public java.util.SequencedCollection<E> reversed();
+ }
+
+ @FlaggedApi("com.android.libcore.v_apis") public interface SequencedMap<K, V> extends java.util.Map<K,V> {
+ method @FlaggedApi("com.android.libcore.v_apis") public default java.util.Map.Entry<K,V> firstEntry();
+ method @FlaggedApi("com.android.libcore.v_apis") public default java.util.Map.Entry<K,V> lastEntry();
+ method @FlaggedApi("com.android.libcore.v_apis") public default java.util.Map.Entry<K,V> pollFirstEntry();
+ method @FlaggedApi("com.android.libcore.v_apis") public default java.util.Map.Entry<K,V> pollLastEntry();
+ method @FlaggedApi("com.android.libcore.v_apis") public default V putFirst(K, V);
+ method @FlaggedApi("com.android.libcore.v_apis") public default V putLast(K, V);
+ method @FlaggedApi("com.android.libcore.v_apis") public java.util.SequencedMap<K,V> reversed();
+ method @FlaggedApi("com.android.libcore.v_apis") public default java.util.SequencedSet<java.util.Map.Entry<K,V>> sequencedEntrySet();
+ method @FlaggedApi("com.android.libcore.v_apis") public default java.util.SequencedSet<K> sequencedKeySet();
+ method @FlaggedApi("com.android.libcore.v_apis") public default java.util.SequencedCollection<V> sequencedValues();
+ }
+
+ @FlaggedApi("com.android.libcore.v_apis") public interface SequencedSet<E> extends java.util.SequencedCollection<E> java.util.Set<E> {
+ method @FlaggedApi("com.android.libcore.v_apis") public java.util.SequencedSet<E> reversed();
+ }
+
public class ServiceConfigurationError extends java.lang.Error {
ctor public ServiceConfigurationError(String);
ctor public ServiceConfigurationError(String, Throwable);
@@ -14780,20 +14838,23 @@
field public static final int WALL_TIME = 0; // 0x0
}
- public interface SortedMap<K, V> extends java.util.Map<K,V> {
+ public interface SortedMap<K, V> extends java.util.SequencedMap<K,V> java.util.Map<K,V> {
method @Nullable public java.util.Comparator<? super K> comparator();
method public K firstKey();
method @NonNull public java.util.SortedMap<K,V> headMap(K);
method public K lastKey();
+ method @FlaggedApi("com.android.libcore.v_apis") @NonNull public default java.util.SortedMap<K,V> reversed();
method @NonNull public java.util.SortedMap<K,V> subMap(K, K);
method @NonNull public java.util.SortedMap<K,V> tailMap(K);
}
- public interface SortedSet<E> extends java.util.Set<E> {
+ public interface SortedSet<E> extends java.util.Set<E> java.util.SequencedSet<E> {
method public java.util.Comparator<? super E> comparator();
method public E first();
method public java.util.SortedSet<E> headSet(E);
method public E last();
+ method @FlaggedApi("com.android.libcore.v_apis") public default java.util.SortedSet<E> reversed();
+ method @FlaggedApi("com.android.libcore.v_apis") public default java.util.Spliterator<E> spliterator();
method public java.util.SortedSet<E> subSet(E, E);
method public java.util.SortedSet<E> tailSet(E);
}
@@ -15046,7 +15107,9 @@
method @NonNull public java.util.NavigableSet<K> navigableKeySet();
method @Nullable public java.util.Map.Entry<K,V> pollFirstEntry();
method @Nullable public java.util.Map.Entry<K,V> pollLastEntry();
+ method @FlaggedApi("com.android.libcore.v_apis") @Nullable public V putFirst(K, V);
method @Nullable public V putIfAbsent(K, V);
+ method @FlaggedApi("com.android.libcore.v_apis") @Nullable public V putLast(K, V);
method public boolean replace(K, @Nullable V, V);
method public V replace(K, V);
method public void replaceAll(@NonNull java.util.function.BiFunction<? super K,? super V,? extends V>);
@@ -15061,6 +15124,8 @@
ctor public TreeSet(java.util.Comparator<? super E>);
ctor public TreeSet(java.util.Collection<? extends E>);
ctor public TreeSet(java.util.SortedSet<E>);
+ method @FlaggedApi("com.android.libcore.v_apis") public void addFirst(E);
+ method @FlaggedApi("com.android.libcore.v_apis") public void addLast(E);
method public E ceiling(E);
method public Object clone();
method public java.util.Comparator<? super E> comparator();
@@ -15559,7 +15624,9 @@
method public java.util.NavigableSet<K> navigableKeySet();
method public java.util.Map.Entry<K,V> pollFirstEntry();
method public java.util.Map.Entry<K,V> pollLastEntry();
+ method @FlaggedApi("com.android.libcore.v_apis") public V putFirst(K, V);
method public V putIfAbsent(K, V);
+ method @FlaggedApi("com.android.libcore.v_apis") public V putLast(K, V);
method public boolean remove(Object, Object);
method public boolean replace(K, V, V);
method public V replace(K, V);
@@ -15575,6 +15642,8 @@
ctor public ConcurrentSkipListSet(java.util.Comparator<? super E>);
ctor public ConcurrentSkipListSet(java.util.Collection<? extends E>);
ctor public ConcurrentSkipListSet(java.util.SortedSet<E>);
+ method @FlaggedApi("com.android.libcore.v_apis") public void addFirst(E);
+ method @FlaggedApi("com.android.libcore.v_apis") public void addLast(E);
method public E ceiling(E);
method public java.util.concurrent.ConcurrentSkipListSet<E> clone();
method public java.util.Comparator<? super E> comparator();
@@ -15607,7 +15676,9 @@
method public boolean addAll(@NonNull java.util.Collection<? extends E>);
method public boolean addAll(int, @NonNull java.util.Collection<? extends E>);
method public int addAllAbsent(@NonNull java.util.Collection<? extends E>);
+ method @FlaggedApi("com.android.libcore.v_apis") public void addFirst(E);
method public boolean addIfAbsent(E);
+ method @FlaggedApi("com.android.libcore.v_apis") public void addLast(E);
method public void clear();
method @NonNull public Object clone();
method public boolean contains(@Nullable Object);
@@ -15615,6 +15686,8 @@
method public boolean equals(@Nullable Object);
method public void forEach(@NonNull java.util.function.Consumer<? super E>);
method public E get(int);
+ method @FlaggedApi("com.android.libcore.v_apis") public E getFirst();
+ method @FlaggedApi("com.android.libcore.v_apis") public E getLast();
method public int hashCode();
method public int indexOf(@Nullable Object);
method public int indexOf(@Nullable E, int);
@@ -15627,9 +15700,12 @@
method public E remove(int);
method public boolean remove(@Nullable Object);
method public boolean removeAll(@NonNull java.util.Collection<?>);
+ method @FlaggedApi("com.android.libcore.v_apis") public E removeFirst();
method public boolean removeIf(@NonNull java.util.function.Predicate<? super E>);
+ method @FlaggedApi("com.android.libcore.v_apis") public E removeLast();
method public void replaceAll(@NonNull java.util.function.UnaryOperator<E>);
method public boolean retainAll(@NonNull java.util.Collection<?>);
+ method @FlaggedApi("com.android.libcore.v_apis") @NonNull public java.util.List<E> reversed();
method public E set(int, E);
method public int size();
method public void sort(@Nullable java.util.Comparator<? super E>);
diff --git a/api/module-lib-current.txt b/api/module-lib-current.txt
index 0ff15ea..ad36b7d 100644
--- a/api/module-lib-current.txt
+++ b/api/module-lib-current.txt
@@ -530,7 +530,7 @@
package java.util {
- public class LinkedHashMap<K, V> extends java.util.HashMap<K,V> implements java.util.Map<K,V> {
+ public class LinkedHashMap<K, V> extends java.util.HashMap<K,V> implements java.util.Map<K,V> java.util.SequencedMap<K,V> {
method public java.util.Map.Entry<K,V> eldest();
}
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/java/util/CollectionsTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/java/util/CollectionsTest.java
index de7ed36..ec1efe7 100644
--- a/harmony-tests/src/test/java/org/apache/harmony/tests/java/util/CollectionsTest.java
+++ b/harmony-tests/src/test/java/org/apache/harmony/tests/java/util/CollectionsTest.java
@@ -53,6 +53,7 @@
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
+import java.util.random.RandomGenerator;
public class CollectionsTest extends junit.framework.TestCase {
@@ -604,6 +605,10 @@
List<String> list = Arrays.asList("A", "B", "C", "D", "E", "F", "G");
Collections.shuffle(list, new Random(0));
assertEquals(Arrays.asList("B", "A", "D", "C", "G", "E", "F"), list);
+
+ list = Arrays.asList("A", "B", "C", "D", "E", "F", "G");
+ Collections.shuffle(list, (RandomGenerator) new Random(0));
+ assertEquals(Arrays.asList("B", "A", "D", "C", "G", "E", "F"), list);
}
public void testShuffleWithSeededRandom() {
diff --git a/luni/src/test/java/libcore/java/util/HashMapTest.java b/luni/src/test/java/libcore/java/util/HashMapTest.java
index 303a870..14ee337 100644
--- a/luni/src/test/java/libcore/java/util/HashMapTest.java
+++ b/luni/src/test/java/libcore/java/util/HashMapTest.java
@@ -248,4 +248,10 @@
fail();
} catch(NullPointerException expected) {}
}
+
+ public void test_newHashMap() {
+ HashMap<String, Object> h1 = HashMap.newHashMap(5);
+ assertTrue(h1.isEmpty());
+ assertEquals(HashMap.class, h1.getClass());
+ }
}
diff --git a/luni/src/test/java/libcore/java/util/HashSetTest.java b/luni/src/test/java/libcore/java/util/HashSetTest.java
new file mode 100644
index 0000000..d71350a
--- /dev/null
+++ b/luni/src/test/java/libcore/java/util/HashSetTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package libcore.java.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.util.HashSet;
+
+@RunWith(JUnit4.class)
+public class HashSetTest {
+
+ @Test
+ public void testNewHashSet() {
+ HashSet<String> h1 = HashSet.newHashSet(5);
+ assertTrue(h1.isEmpty());
+ assertEquals(HashSet.class, h1.getClass());
+
+ }
+}
diff --git a/ojluni/annotations/flagged_api/java/util/ArrayList.annotated.java b/ojluni/annotations/flagged_api/java/util/ArrayList.annotated.java
new file mode 100644
index 0000000..1efaa95
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/ArrayList.annotated.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ArrayList<E> extends java.util.AbstractList<E> implements java.util.List<E>, java.util.RandomAccess, java.lang.Cloneable, java.io.Serializable {
+
+public ArrayList(int initialCapacity) { throw new RuntimeException("Stub!"); }
+
+public ArrayList() { throw new RuntimeException("Stub!"); }
+
+public ArrayList(java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public void trimToSize() { throw new RuntimeException("Stub!"); }
+
+public void ensureCapacity(int minCapacity) { throw new RuntimeException("Stub!"); }
+
+public int size() { throw new RuntimeException("Stub!"); }
+
+public boolean isEmpty() { throw new RuntimeException("Stub!"); }
+
+public boolean contains(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public int indexOf(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public int lastIndexOf(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+
+public java.lang.Object[] toArray() { throw new RuntimeException("Stub!"); }
+
+public <T> T[] toArray(T[] a) { throw new RuntimeException("Stub!"); }
+
+public E get(int index) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public E getFirst() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public E getLast() { throw new RuntimeException("Stub!"); }
+
+public E set(int index, E element) { throw new RuntimeException("Stub!"); }
+
+public boolean add(E e) { throw new RuntimeException("Stub!"); }
+
+public void add(int index, E element) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public void addFirst(E element) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public void addLast(E element) { throw new RuntimeException("Stub!"); }
+
+public E remove(int index) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public E removeFirst() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public E removeLast() { throw new RuntimeException("Stub!"); }
+
+public boolean equals(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public int hashCode() { throw new RuntimeException("Stub!"); }
+
+public boolean remove(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public void clear() { throw new RuntimeException("Stub!"); }
+
+public boolean addAll(java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public boolean addAll(int index, java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+protected void removeRange(int fromIndex, int toIndex) { throw new RuntimeException("Stub!"); }
+
+public boolean removeAll(java.util.Collection<?> c) { throw new RuntimeException("Stub!"); }
+
+public boolean retainAll(java.util.Collection<?> c) { throw new RuntimeException("Stub!"); }
+
+public java.util.ListIterator<E> listIterator(int index) { throw new RuntimeException("Stub!"); }
+
+public java.util.ListIterator<E> listIterator() { throw new RuntimeException("Stub!"); }
+
+public java.util.Iterator<E> iterator() { throw new RuntimeException("Stub!"); }
+
+public java.util.List<E> subList(int fromIndex, int toIndex) { throw new RuntimeException("Stub!"); }
+
+public void forEach(java.util.function.Consumer<? super E> action) { throw new RuntimeException("Stub!"); }
+
+public java.util.Spliterator<E> spliterator() { throw new RuntimeException("Stub!"); }
+
+public boolean removeIf(java.util.function.Predicate<? super E> filter) { throw new RuntimeException("Stub!"); }
+
+public void replaceAll(java.util.function.UnaryOperator<E> operator) { throw new RuntimeException("Stub!"); }
+
+public void sort(java.util.Comparator<? super E> c) { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/Collections.annotated.java b/ojluni/annotations/flagged_api/java/util/Collections.annotated.java
new file mode 100644
index 0000000..60d8148
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/Collections.annotated.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class Collections {
+
+Collections() { throw new RuntimeException("Stub!"); }
+
+public static <T extends java.lang.Comparable<? super T>> void sort(java.util.List<T> list) { throw new RuntimeException("Stub!"); }
+
+public static <T> void sort(java.util.List<T> list, java.util.Comparator<? super T> c) { throw new RuntimeException("Stub!"); }
+
+public static <T> int binarySearch(java.util.List<? extends java.lang.Comparable<? super T>> list, T key) { throw new RuntimeException("Stub!"); }
+
+public static <T> int binarySearch(java.util.List<? extends T> list, T key, java.util.Comparator<? super T> c) { throw new RuntimeException("Stub!"); }
+
+public static void reverse(java.util.List<?> list) { throw new RuntimeException("Stub!"); }
+
+public static void shuffle(java.util.List<?> list) { throw new RuntimeException("Stub!"); }
+
+public static void shuffle(java.util.List<?> list, java.util.Random rnd) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public static void shuffle(java.util.List<?> list, java.util.random.RandomGenerator rnd) { throw new RuntimeException("Stub!"); }
+
+public static void swap(java.util.List<?> list, int i, int j) { throw new RuntimeException("Stub!"); }
+
+public static <T> void fill(java.util.List<? super T> list, T obj) { throw new RuntimeException("Stub!"); }
+
+public static <T> void copy(java.util.List<? super T> dest, java.util.List<? extends T> src) { throw new RuntimeException("Stub!"); }
+
+public static <T extends java.lang.Object & java.lang.Comparable<? super T>> T min(java.util.Collection<? extends T> coll) { throw new RuntimeException("Stub!"); }
+
+public static <T> T min(java.util.Collection<? extends T> coll, java.util.Comparator<? super T> comp) { throw new RuntimeException("Stub!"); }
+
+public static <T extends java.lang.Object & java.lang.Comparable<? super T>> T max(java.util.Collection<? extends T> coll) { throw new RuntimeException("Stub!"); }
+
+public static <T> T max(java.util.Collection<? extends T> coll, java.util.Comparator<? super T> comp) { throw new RuntimeException("Stub!"); }
+
+public static void rotate(java.util.List<?> list, int distance) { throw new RuntimeException("Stub!"); }
+
+public static <T> boolean replaceAll(java.util.List<T> list, T oldVal, T newVal) { throw new RuntimeException("Stub!"); }
+
+public static int indexOfSubList(java.util.List<?> source, java.util.List<?> target) { throw new RuntimeException("Stub!"); }
+
+public static int lastIndexOfSubList(java.util.List<?> source, java.util.List<?> target) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.Collection<T> unmodifiableCollection(java.util.Collection<? extends T> c) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.Set<T> unmodifiableSet(java.util.Set<? extends T> s) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.SortedSet<T> unmodifiableSortedSet(java.util.SortedSet<T> s) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.NavigableSet<T> unmodifiableNavigableSet(java.util.NavigableSet<T> s) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.List<T> unmodifiableList(java.util.List<? extends T> list) { throw new RuntimeException("Stub!"); }
+
+public static <K, V> java.util.Map<K,V> unmodifiableMap(java.util.Map<? extends K,? extends V> m) { throw new RuntimeException("Stub!"); }
+
+public static <K, V> java.util.SortedMap<K,V> unmodifiableSortedMap(java.util.SortedMap<K,? extends V> m) { throw new RuntimeException("Stub!"); }
+
+public static <K, V> java.util.NavigableMap<K,V> unmodifiableNavigableMap(java.util.NavigableMap<K,? extends V> m) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.Collection<T> synchronizedCollection(java.util.Collection<T> c) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.Set<T> synchronizedSet(java.util.Set<T> s) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.SortedSet<T> synchronizedSortedSet(java.util.SortedSet<T> s) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.NavigableSet<T> synchronizedNavigableSet(java.util.NavigableSet<T> s) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.List<T> synchronizedList(java.util.List<T> list) { throw new RuntimeException("Stub!"); }
+
+public static <K, V> java.util.Map<K,V> synchronizedMap(java.util.Map<K,V> m) { throw new RuntimeException("Stub!"); }
+
+public static <K, V> java.util.SortedMap<K,V> synchronizedSortedMap(java.util.SortedMap<K,V> m) { throw new RuntimeException("Stub!"); }
+
+public static <K, V> java.util.NavigableMap<K,V> synchronizedNavigableMap(java.util.NavigableMap<K,V> m) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.Collection<E> checkedCollection(java.util.Collection<E> c, java.lang.Class<E> type) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.Queue<E> checkedQueue(java.util.Queue<E> queue, java.lang.Class<E> type) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.Set<E> checkedSet(java.util.Set<E> s, java.lang.Class<E> type) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.SortedSet<E> checkedSortedSet(java.util.SortedSet<E> s, java.lang.Class<E> type) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.NavigableSet<E> checkedNavigableSet(java.util.NavigableSet<E> s, java.lang.Class<E> type) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> checkedList(java.util.List<E> list, java.lang.Class<E> type) { throw new RuntimeException("Stub!"); }
+
+public static <K, V> java.util.Map<K,V> checkedMap(java.util.Map<K,V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType) { throw new RuntimeException("Stub!"); }
+
+public static <K, V> java.util.SortedMap<K,V> checkedSortedMap(java.util.SortedMap<K,V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType) { throw new RuntimeException("Stub!"); }
+
+public static <K, V> java.util.NavigableMap<K,V> checkedNavigableMap(java.util.NavigableMap<K,V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.Iterator<T> emptyIterator() { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.ListIterator<T> emptyListIterator() { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.Enumeration<T> emptyEnumeration() { throw new RuntimeException("Stub!"); }
+
+public static final <T> java.util.Set<T> emptySet() { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.SortedSet<E> emptySortedSet() { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.NavigableSet<E> emptyNavigableSet() { throw new RuntimeException("Stub!"); }
+
+public static final <T> java.util.List<T> emptyList() { throw new RuntimeException("Stub!"); }
+
+public static final <K, V> java.util.Map<K,V> emptyMap() { throw new RuntimeException("Stub!"); }
+
+public static final <K, V> java.util.SortedMap<K,V> emptySortedMap() { throw new RuntimeException("Stub!"); }
+
+public static final <K, V> java.util.NavigableMap<K,V> emptyNavigableMap() { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.Set<T> singleton(T o) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.List<T> singletonList(T o) { throw new RuntimeException("Stub!"); }
+
+public static <K, V> java.util.Map<K,V> singletonMap(K key, V value) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.List<T> nCopies(int n, T o) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.Comparator<T> reverseOrder() { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.Comparator<T> reverseOrder(java.util.Comparator<T> cmp) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.Enumeration<T> enumeration(java.util.Collection<T> c) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.ArrayList<T> list(java.util.Enumeration<T> e) { throw new RuntimeException("Stub!"); }
+
+public static int frequency(java.util.Collection<?> c, java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public static boolean disjoint(java.util.Collection<?> c1, java.util.Collection<?> c2) { throw new RuntimeException("Stub!"); }
+
+@java.lang.SafeVarargs
+public static <T> boolean addAll(java.util.Collection<? super T> c, T... elements) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.Set<E> newSetFromMap(java.util.Map<E,java.lang.Boolean> map) { throw new RuntimeException("Stub!"); }
+
+public static <T> java.util.Queue<T> asLifoQueue(java.util.Deque<T> deque) { throw new RuntimeException("Stub!"); }
+
+public static final java.util.List EMPTY_LIST;
+static { EMPTY_LIST = null; }
+
+public static final java.util.Map EMPTY_MAP;
+static { EMPTY_MAP = null; }
+
+public static final java.util.Set EMPTY_SET;
+static { EMPTY_SET = null; }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/Deque.annotated.java b/ojluni/annotations/flagged_api/java/util/Deque.annotated.java
new file mode 100644
index 0000000..69af0df
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/Deque.annotated.java
@@ -0,0 +1,102 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea and Josh Bloch with assistance from members of
+ * JCP JSR-166 Expert Group and released to the public domain, as explained
+ * at http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public interface Deque<E> extends java.util.Queue<E>, java.util.SequencedCollection<E> {
+
+public void addFirst(E e);
+
+public void addLast(E e);
+
+public boolean offerFirst(E e);
+
+public boolean offerLast(E e);
+
+public E removeFirst();
+
+public E removeLast();
+
+public E pollFirst();
+
+public E pollLast();
+
+public E getFirst();
+
+public E getLast();
+
+public E peekFirst();
+
+public E peekLast();
+
+public boolean removeFirstOccurrence(java.lang.Object o);
+
+public boolean removeLastOccurrence(java.lang.Object o);
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public boolean add(E e);
+
+public boolean offer(E e);
+
+public E remove();
+
+public E poll();
+
+public E element();
+
+public E peek();
+
+public boolean addAll(java.util.Collection<? extends E> c);
+
+public void push(E e);
+
+public E pop();
+
+public boolean remove(java.lang.Object o);
+
+public boolean contains(java.lang.Object o);
+
+public int size();
+
+public java.util.Iterator<E> iterator();
+
+public java.util.Iterator<E> descendingIterator();
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.Deque<E> reversed() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/HashMap.annotated.java b/ojluni/annotations/flagged_api/java/util/HashMap.annotated.java
new file mode 100644
index 0000000..878d56e
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/HashMap.annotated.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify itA
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class HashMap<K, V> extends java.util.AbstractMap<K,V> implements java.util.Map<K,V>, java.lang.Cloneable, java.io.Serializable {
+
+public HashMap(int initialCapacity, float loadFactor) { throw new RuntimeException("Stub!"); }
+
+public HashMap(int initialCapacity) { throw new RuntimeException("Stub!"); }
+
+public HashMap() { throw new RuntimeException("Stub!"); }
+
+public HashMap(java.util.Map<? extends K,? extends V> m) { throw new RuntimeException("Stub!"); }
+
+public int size() { throw new RuntimeException("Stub!"); }
+
+public boolean isEmpty() { throw new RuntimeException("Stub!"); }
+
+public V get(java.lang.Object key) { throw new RuntimeException("Stub!"); }
+
+public boolean containsKey(java.lang.Object key) { throw new RuntimeException("Stub!"); }
+
+public V put(K key, V value) { throw new RuntimeException("Stub!"); }
+
+public void putAll(java.util.Map<? extends K,? extends V> m) { throw new RuntimeException("Stub!"); }
+
+public V remove(java.lang.Object key) { throw new RuntimeException("Stub!"); }
+
+public void clear() { throw new RuntimeException("Stub!"); }
+
+public boolean containsValue(java.lang.Object value) { throw new RuntimeException("Stub!"); }
+
+public java.util.Set<K> keySet() { throw new RuntimeException("Stub!"); }
+
+public java.util.Collection<V> values() { throw new RuntimeException("Stub!"); }
+
+public java.util.Set<java.util.Map.Entry<K,V>> entrySet() { throw new RuntimeException("Stub!"); }
+
+public V getOrDefault(java.lang.Object key, V defaultValue) { throw new RuntimeException("Stub!"); }
+
+public V putIfAbsent(K key, V value) { throw new RuntimeException("Stub!"); }
+
+public boolean remove(java.lang.Object key, java.lang.Object value) { throw new RuntimeException("Stub!"); }
+
+public boolean replace(K key, V oldValue, V newValue) { throw new RuntimeException("Stub!"); }
+
+public V replace(K key, V value) { throw new RuntimeException("Stub!"); }
+
+public V computeIfAbsent(K key, java.util.function.Function<? super K,? extends V> mappingFunction) { throw new RuntimeException("Stub!"); }
+
+public V computeIfPresent(K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction) { throw new RuntimeException("Stub!"); }
+
+public V compute(K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction) { throw new RuntimeException("Stub!"); }
+
+public V merge(K key, V value, java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction) { throw new RuntimeException("Stub!"); }
+
+public void forEach(java.util.function.BiConsumer<? super K,? super V> action) { throw new RuntimeException("Stub!"); }
+
+public void replaceAll(java.util.function.BiFunction<? super K,? super V,? extends V> function) { throw new RuntimeException("Stub!"); }
+
+public java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public static <K, V> java.util.HashMap<K,V> newHashMap(int numMappings) { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/HashSet.annotated.java b/ojluni/annotations/flagged_api/java/util/HashSet.annotated.java
new file mode 100644
index 0000000..6a29ba9
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/HashSet.annotated.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class HashSet<E> extends java.util.AbstractSet<E> implements java.util.Set<E>, java.lang.Cloneable, java.io.Serializable {
+
+public HashSet() { throw new RuntimeException("Stub!"); }
+
+public HashSet(java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public HashSet(int initialCapacity, float loadFactor) { throw new RuntimeException("Stub!"); }
+
+public HashSet(int initialCapacity) { throw new RuntimeException("Stub!"); }
+
+public java.util.Iterator<E> iterator() { throw new RuntimeException("Stub!"); }
+
+public int size() { throw new RuntimeException("Stub!"); }
+
+public boolean isEmpty() { throw new RuntimeException("Stub!"); }
+
+public boolean contains(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public boolean add(E e) { throw new RuntimeException("Stub!"); }
+
+public boolean remove(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public void clear() { throw new RuntimeException("Stub!"); }
+
+public java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+
+public java.util.Spliterator<E> spliterator() { throw new RuntimeException("Stub!"); }
+
+public java.lang.Object[] toArray() { throw new RuntimeException("Stub!"); }
+
+public <T> T[] toArray(T[] a) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public static <T> java.util.HashSet<T> newHashSet(int numElements) { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/LinkedHashMap.annotated.java b/ojluni/annotations/flagged_api/java/util/LinkedHashMap.annotated.java
new file mode 100644
index 0000000..7ab7e99
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/LinkedHashMap.annotated.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class LinkedHashMap<K, V> extends java.util.HashMap<K,V> implements java.util.SequencedMap<K,V>, java.util.Map<K,V> {
+
+public LinkedHashMap(int initialCapacity, float loadFactor) { throw new RuntimeException("Stub!"); }
+
+public LinkedHashMap(int initialCapacity) { throw new RuntimeException("Stub!"); }
+
+public LinkedHashMap() { throw new RuntimeException("Stub!"); }
+
+public LinkedHashMap(java.util.Map<? extends K,? extends V> m) { throw new RuntimeException("Stub!"); }
+
+public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public V putFirst(K k, V v) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public V putLast(K k, V v) { throw new RuntimeException("Stub!"); }
+
+public boolean containsValue(java.lang.Object value) { throw new RuntimeException("Stub!"); }
+
+public V get(java.lang.Object key) { throw new RuntimeException("Stub!"); }
+
+public V getOrDefault(java.lang.Object key, V defaultValue) { throw new RuntimeException("Stub!"); }
+
+public void clear() { throw new RuntimeException("Stub!"); }
+
+protected boolean removeEldestEntry(java.util.Map.Entry<K,V> eldest) { throw new RuntimeException("Stub!"); }
+
+public java.util.Set<K> keySet() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public java.util.SequencedSet<K> sequencedKeySet() { throw new RuntimeException("Stub!"); }
+
+public java.util.Collection<V> values() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public java.util.SequencedCollection<V> sequencedValues() { throw new RuntimeException("Stub!"); }
+
+public java.util.Set<java.util.Map.Entry<K,V>> entrySet() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public java.util.SequencedSet<java.util.Map.Entry<K,V>> sequencedEntrySet() { throw new RuntimeException("Stub!"); }
+
+public void forEach(java.util.function.BiConsumer<? super K,? super V> action) { throw new RuntimeException("Stub!"); }
+
+public void replaceAll(java.util.function.BiFunction<? super K,? super V,? extends V> function) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public static <K, V> java.util.LinkedHashMap<K,V> newLinkedHashMap(int numMappings) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public java.util.SequencedMap<K,V> reversed() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/LinkedHashSet.annotated.java b/ojluni/annotations/flagged_api/java/util/LinkedHashSet.annotated.java
new file mode 100644
index 0000000..dae8756
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/LinkedHashSet.annotated.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2000, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class LinkedHashSet<E> extends java.util.HashSet<E> implements java.util.SequencedSet<E>, java.util.Set<E>, java.lang.Cloneable, java.io.Serializable {
+
+public LinkedHashSet(int initialCapacity, float loadFactor) { throw new RuntimeException("Stub!"); }
+
+public LinkedHashSet(int initialCapacity) { throw new RuntimeException("Stub!"); }
+
+public LinkedHashSet() { throw new RuntimeException("Stub!"); }
+
+public LinkedHashSet(java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public java.util.Spliterator<E> spliterator() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public static <T> java.util.LinkedHashSet<T> newLinkedHashSet(int numElements) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public void addFirst(E e) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public void addLast(E e) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public E getFirst() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public E getLast() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public E removeFirst() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public E removeLast() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public java.util.SequencedSet<E> reversed() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/LinkedList.annotated.java b/ojluni/annotations/flagged_api/java/util/LinkedList.annotated.java
new file mode 100644
index 0000000..985f849
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/LinkedList.annotated.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class LinkedList<E> extends java.util.AbstractSequentialList<E> implements java.util.List<E>, java.util.Deque<E>, java.lang.Cloneable, java.io.Serializable {
+
+public LinkedList() { throw new RuntimeException("Stub!"); }
+
+public LinkedList(java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public E getFirst() { throw new RuntimeException("Stub!"); }
+
+public E getLast() { throw new RuntimeException("Stub!"); }
+
+public E removeFirst() { throw new RuntimeException("Stub!"); }
+
+public E removeLast() { throw new RuntimeException("Stub!"); }
+
+public void addFirst(E e) { throw new RuntimeException("Stub!"); }
+
+public void addLast(E e) { throw new RuntimeException("Stub!"); }
+
+public boolean contains(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public int size() { throw new RuntimeException("Stub!"); }
+
+public boolean add(E e) { throw new RuntimeException("Stub!"); }
+
+public boolean remove(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public boolean addAll(java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public boolean addAll(int index, java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public void clear() { throw new RuntimeException("Stub!"); }
+
+public E get(int index) { throw new RuntimeException("Stub!"); }
+
+public E set(int index, E element) { throw new RuntimeException("Stub!"); }
+
+public void add(int index, E element) { throw new RuntimeException("Stub!"); }
+
+public E remove(int index) { throw new RuntimeException("Stub!"); }
+
+public int indexOf(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public int lastIndexOf(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public E peek() { throw new RuntimeException("Stub!"); }
+
+public E element() { throw new RuntimeException("Stub!"); }
+
+public E poll() { throw new RuntimeException("Stub!"); }
+
+public E remove() { throw new RuntimeException("Stub!"); }
+
+public boolean offer(E e) { throw new RuntimeException("Stub!"); }
+
+public boolean offerFirst(E e) { throw new RuntimeException("Stub!"); }
+
+public boolean offerLast(E e) { throw new RuntimeException("Stub!"); }
+
+public E peekFirst() { throw new RuntimeException("Stub!"); }
+
+public E peekLast() { throw new RuntimeException("Stub!"); }
+
+public E pollFirst() { throw new RuntimeException("Stub!"); }
+
+public E pollLast() { throw new RuntimeException("Stub!"); }
+
+public void push(E e) { throw new RuntimeException("Stub!"); }
+
+public E pop() { throw new RuntimeException("Stub!"); }
+
+public boolean removeFirstOccurrence(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public boolean removeLastOccurrence(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public java.util.ListIterator<E> listIterator(int index) { throw new RuntimeException("Stub!"); }
+
+public java.util.Iterator<E> descendingIterator() { throw new RuntimeException("Stub!"); }
+
+public java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+
+public java.lang.Object[] toArray() { throw new RuntimeException("Stub!"); }
+
+public <T> T[] toArray(T[] a) { throw new RuntimeException("Stub!"); }
+
+public java.util.Spliterator<E> spliterator() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public java.util.LinkedList<E> reversed() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/List.annotated.java b/ojluni/annotations/flagged_api/java/util/List.annotated.java
new file mode 100644
index 0000000..c8ce5c0
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/List.annotated.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public interface List<E> extends java.util.SequencedCollection<E>, java.util.Collection<E> {
+
+public int size();
+
+public boolean isEmpty();
+
+public boolean contains(java.lang.Object o);
+
+public java.util.Iterator<E> iterator();
+
+public java.lang.Object[] toArray();
+
+public <T> T[] toArray(T[] a);
+
+public boolean add(E e);
+
+public boolean remove(java.lang.Object o);
+
+public boolean containsAll(java.util.Collection<?> c);
+
+public boolean addAll(java.util.Collection<? extends E> c);
+
+public boolean addAll(int index, java.util.Collection<? extends E> c);
+
+public boolean removeAll(java.util.Collection<?> c);
+
+public boolean retainAll(java.util.Collection<?> c);
+
+public default void replaceAll(java.util.function.UnaryOperator<E> operator) { throw new RuntimeException("Stub!"); }
+
+public default void sort(java.util.Comparator<? super E> c) { throw new RuntimeException("Stub!"); }
+
+public void clear();
+
+public boolean equals(java.lang.Object o);
+
+public int hashCode();
+
+public E get(int index);
+
+public E set(int index, E element);
+
+public void add(int index, E element);
+
+public E remove(int index);
+
+public int indexOf(java.lang.Object o);
+
+public int lastIndexOf(java.lang.Object o);
+
+public java.util.ListIterator<E> listIterator();
+
+public java.util.ListIterator<E> listIterator(int index);
+
+public java.util.List<E> subList(int fromIndex, int toIndex);
+
+public default java.util.Spliterator<E> spliterator() { throw new RuntimeException("Stub!"); }
+
+public default void addFirst(E e) { throw new RuntimeException("Stub!"); }
+
+public default void addLast(E e) { throw new RuntimeException("Stub!"); }
+
+public default E getFirst() { throw new RuntimeException("Stub!"); }
+
+public default E getLast() { throw new RuntimeException("Stub!"); }
+
+public default E removeFirst() { throw new RuntimeException("Stub!"); }
+
+public default E removeLast() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.List<E> reversed() { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> of() { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> of(E e1) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> of(E e1, E e2) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> of(E e1, E e2, E e3) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> of(E e1, E e2, E e3, E e4) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5, E e6) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) { throw new RuntimeException("Stub!"); }
+
+@java.lang.SafeVarargs
+public static <E> java.util.List<E> of(E... elements) { throw new RuntimeException("Stub!"); }
+
+public static <E> java.util.List<E> copyOf(java.util.Collection<? extends E> coll) { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/NavigableMap.annotated.java b/ojluni/annotations/flagged_api/java/util/NavigableMap.annotated.java
new file mode 100644
index 0000000..82c23d6
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/NavigableMap.annotated.java
@@ -0,0 +1,87 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea and Josh Bloch with assistance from members of JCP
+ * JSR-166 Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public interface NavigableMap<K, V> extends java.util.SortedMap<K,V> {
+
+public java.util.Map.Entry<K,V> lowerEntry(K key);
+
+public K lowerKey(K key);
+
+public java.util.Map.Entry<K,V> floorEntry(K key);
+
+public K floorKey(K key);
+
+public java.util.Map.Entry<K,V> ceilingEntry(K key);
+
+public K ceilingKey(K key);
+
+public java.util.Map.Entry<K,V> higherEntry(K key);
+
+public K higherKey(K key);
+
+public java.util.Map.Entry<K,V> firstEntry();
+
+public java.util.Map.Entry<K,V> lastEntry();
+
+public java.util.Map.Entry<K,V> pollFirstEntry();
+
+public java.util.Map.Entry<K,V> pollLastEntry();
+
+public java.util.NavigableMap<K,V> descendingMap();
+
+public java.util.NavigableSet<K> navigableKeySet();
+
+public java.util.NavigableSet<K> descendingKeySet();
+
+public java.util.NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive);
+
+public java.util.NavigableMap<K,V> headMap(K toKey, boolean inclusive);
+
+public java.util.NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);
+
+public java.util.SortedMap<K,V> subMap(K fromKey, K toKey);
+
+public java.util.SortedMap<K,V> headMap(K toKey);
+
+public java.util.SortedMap<K,V> tailMap(K fromKey);
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.NavigableMap<K,V> reversed() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/NavigableSet.annotated.java b/ojluni/annotations/flagged_api/java/util/NavigableSet.annotated.java
new file mode 100644
index 0000000..605b2af
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/NavigableSet.annotated.java
@@ -0,0 +1,84 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea and Josh Bloch with assistance from members of JCP
+ * JSR-166 Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+// BEGIN android-note
+// removed link to collections framework docs
+// END android-note
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public interface NavigableSet<E> extends java.util.SortedSet<E> {
+
+public E lower(E e);
+
+public E floor(E e);
+
+public E ceiling(E e);
+
+public E higher(E e);
+
+public E pollFirst();
+
+public E pollLast();
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public java.util.Iterator<E> iterator();
+
+public java.util.NavigableSet<E> descendingSet();
+
+public java.util.Iterator<E> descendingIterator();
+
+public java.util.NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive);
+
+public java.util.NavigableSet<E> headSet(E toElement, boolean inclusive);
+
+public java.util.NavigableSet<E> tailSet(E fromElement, boolean inclusive);
+
+public java.util.SortedSet<E> subSet(E fromElement, E toElement);
+
+public java.util.SortedSet<E> headSet(E toElement);
+
+public java.util.SortedSet<E> tailSet(E fromElement);
+
+public default E removeFirst() { throw new RuntimeException("Stub!"); }
+
+public default E removeLast() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.NavigableSet<E> reversed() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/SequencedCollection.annotated.java b/ojluni/annotations/flagged_api/java/util/SequencedCollection.annotated.java
new file mode 100644
index 0000000..6bd5805
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/SequencedCollection.annotated.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public interface SequencedCollection<E> extends java.util.Collection<E> {
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public java.util.SequencedCollection<E> reversed();
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default void addFirst(E e) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default void addLast(E e) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default E getFirst() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default E getLast() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default E removeFirst() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default E removeLast() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/SequencedMap.annotated.java b/ojluni/annotations/flagged_api/java/util/SequencedMap.annotated.java
new file mode 100644
index 0000000..018a613
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/SequencedMap.annotated.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public interface SequencedMap<K, V> extends java.util.Map<K,V> {
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public java.util.SequencedMap<K,V> reversed();
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.Map.Entry<K,V> firstEntry() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.Map.Entry<K,V> lastEntry() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.Map.Entry<K,V> pollFirstEntry() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.Map.Entry<K,V> pollLastEntry() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default V putFirst(K k, V v) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default V putLast(K k, V v) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.SequencedSet<K> sequencedKeySet() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.SequencedCollection<V> sequencedValues() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.SequencedSet<java.util.Map.Entry<K,V>> sequencedEntrySet() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/SequencedSet.annotated.java b/ojluni/annotations/flagged_api/java/util/SequencedSet.annotated.java
new file mode 100644
index 0000000..4713172
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/SequencedSet.annotated.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public interface SequencedSet<E> extends java.util.SequencedCollection<E>, java.util.Set<E> {
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public java.util.SequencedSet<E> reversed();
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/SortedMap.annotated.java b/ojluni/annotations/flagged_api/java/util/SortedMap.annotated.java
new file mode 100644
index 0000000..a42b35b
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/SortedMap.annotated.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 1998, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public interface SortedMap<K, V> extends java.util.SequencedMap<K,V>, java.util.Map<K,V> {
+
+public java.util.Comparator<? super K> comparator();
+
+public java.util.SortedMap<K,V> subMap(K fromKey, K toKey);
+
+public java.util.SortedMap<K,V> headMap(K toKey);
+
+public java.util.SortedMap<K,V> tailMap(K fromKey);
+
+public K firstKey();
+
+public K lastKey();
+
+public java.util.Set<K> keySet();
+
+public java.util.Collection<V> values();
+
+public java.util.Set<java.util.Map.Entry<K,V>> entrySet();
+
+public default V putFirst(K k, V v) { throw new RuntimeException("Stub!"); }
+
+public default V putLast(K k, V v) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.SortedMap<K,V> reversed() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/SortedSet.annotated.java b/ojluni/annotations/flagged_api/java/util/SortedSet.annotated.java
new file mode 100644
index 0000000..d878cc4
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/SortedSet.annotated.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 1998, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public interface SortedSet<E> extends java.util.Set<E>, java.util.SequencedSet<E> {
+
+public java.util.Comparator<? super E> comparator();
+
+public java.util.SortedSet<E> subSet(E fromElement, E toElement);
+
+public java.util.SortedSet<E> headSet(E toElement);
+
+public java.util.SortedSet<E> tailSet(E fromElement);
+
+public E first();
+
+public E last();
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.Spliterator<E> spliterator() { throw new RuntimeException("Stub!"); }
+
+public default void addFirst(E e) { throw new RuntimeException("Stub!"); }
+
+public default void addLast(E e) { throw new RuntimeException("Stub!"); }
+
+public default E getFirst() { throw new RuntimeException("Stub!"); }
+
+public default E getLast() { throw new RuntimeException("Stub!"); }
+
+public default E removeFirst() { throw new RuntimeException("Stub!"); }
+
+public default E removeLast() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public default java.util.SortedSet<E> reversed() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/TreeMap.annotated.java b/ojluni/annotations/flagged_api/java/util/TreeMap.annotated.java
new file mode 100644
index 0000000..5cff3c3
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/TreeMap.annotated.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class TreeMap<K, V> extends java.util.AbstractMap<K,V> implements java.util.NavigableMap<K,V>, java.lang.Cloneable, java.io.Serializable {
+
+public TreeMap() { throw new RuntimeException("Stub!"); }
+
+public TreeMap(java.util.Comparator<? super K> comparator) { throw new RuntimeException("Stub!"); }
+
+public TreeMap(java.util.Map<? extends K,? extends V> m) { throw new RuntimeException("Stub!"); }
+
+public TreeMap(java.util.SortedMap<K,? extends V> m) { throw new RuntimeException("Stub!"); }
+
+public int size() { throw new RuntimeException("Stub!"); }
+
+public boolean containsKey(java.lang.Object key) { throw new RuntimeException("Stub!"); }
+
+public boolean containsValue(java.lang.Object value) { throw new RuntimeException("Stub!"); }
+
+public V get(java.lang.Object key) { throw new RuntimeException("Stub!"); }
+
+public java.util.Comparator<? super K> comparator() { throw new RuntimeException("Stub!"); }
+
+public K firstKey() { throw new RuntimeException("Stub!"); }
+
+public K lastKey() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public V putFirst(K k, V v) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public V putLast(K k, V v) { throw new RuntimeException("Stub!"); }
+
+public void putAll(java.util.Map<? extends K,? extends V> map) { throw new RuntimeException("Stub!"); }
+
+public V put(K key, V value) { throw new RuntimeException("Stub!"); }
+
+public V putIfAbsent(K key, V value) { throw new RuntimeException("Stub!"); }
+
+public V computeIfAbsent(K key, java.util.function.Function<? super K,? extends V> mappingFunction) { throw new RuntimeException("Stub!"); }
+
+public V computeIfPresent(K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction) { throw new RuntimeException("Stub!"); }
+
+public V compute(K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction) { throw new RuntimeException("Stub!"); }
+
+public V merge(K key, V value, java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction) { throw new RuntimeException("Stub!"); }
+
+public V remove(java.lang.Object key) { throw new RuntimeException("Stub!"); }
+
+public void clear() { throw new RuntimeException("Stub!"); }
+
+public java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> firstEntry() { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> lastEntry() { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> pollFirstEntry() { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> pollLastEntry() { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> lowerEntry(K key) { throw new RuntimeException("Stub!"); }
+
+public K lowerKey(K key) { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> floorEntry(K key) { throw new RuntimeException("Stub!"); }
+
+public K floorKey(K key) { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> ceilingEntry(K key) { throw new RuntimeException("Stub!"); }
+
+public K ceilingKey(K key) { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> higherEntry(K key) { throw new RuntimeException("Stub!"); }
+
+public K higherKey(K key) { throw new RuntimeException("Stub!"); }
+
+public java.util.Set<K> keySet() { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<K> navigableKeySet() { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<K> descendingKeySet() { throw new RuntimeException("Stub!"); }
+
+public java.util.Collection<V> values() { throw new RuntimeException("Stub!"); }
+
+public java.util.Set<java.util.Map.Entry<K,V>> entrySet() { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableMap<K,V> descendingMap() { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableMap<K,V> headMap(K toKey, boolean inclusive) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableMap<K,V> tailMap(K fromKey, boolean inclusive) { throw new RuntimeException("Stub!"); }
+
+public java.util.SortedMap<K,V> subMap(K fromKey, K toKey) { throw new RuntimeException("Stub!"); }
+
+public java.util.SortedMap<K,V> headMap(K toKey) { throw new RuntimeException("Stub!"); }
+
+public java.util.SortedMap<K,V> tailMap(K fromKey) { throw new RuntimeException("Stub!"); }
+
+public boolean replace(K key, V oldValue, V newValue) { throw new RuntimeException("Stub!"); }
+
+public V replace(K key, V value) { throw new RuntimeException("Stub!"); }
+
+public void forEach(java.util.function.BiConsumer<? super K,? super V> action) { throw new RuntimeException("Stub!"); }
+
+public void replaceAll(java.util.function.BiFunction<? super K,? super V,? extends V> function) { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/TreeSet.annotated.java b/ojluni/annotations/flagged_api/java/util/TreeSet.annotated.java
new file mode 100644
index 0000000..e149e39
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/TreeSet.annotated.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 1998, 2023, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+package java.util;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class TreeSet<E> extends java.util.AbstractSet<E> implements java.util.NavigableSet<E>, java.lang.Cloneable, java.io.Serializable {
+
+public TreeSet() { throw new RuntimeException("Stub!"); }
+
+public TreeSet(java.util.Comparator<? super E> comparator) { throw new RuntimeException("Stub!"); }
+
+public TreeSet(java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public TreeSet(java.util.SortedSet<E> s) { throw new RuntimeException("Stub!"); }
+
+public java.util.Iterator<E> iterator() { throw new RuntimeException("Stub!"); }
+
+public java.util.Iterator<E> descendingIterator() { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<E> descendingSet() { throw new RuntimeException("Stub!"); }
+
+public int size() { throw new RuntimeException("Stub!"); }
+
+public boolean isEmpty() { throw new RuntimeException("Stub!"); }
+
+public boolean contains(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public boolean add(E e) { throw new RuntimeException("Stub!"); }
+
+public boolean remove(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public void clear() { throw new RuntimeException("Stub!"); }
+
+public boolean addAll(java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<E> headSet(E toElement, boolean inclusive) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<E> tailSet(E fromElement, boolean inclusive) { throw new RuntimeException("Stub!"); }
+
+public java.util.SortedSet<E> subSet(E fromElement, E toElement) { throw new RuntimeException("Stub!"); }
+
+public java.util.SortedSet<E> headSet(E toElement) { throw new RuntimeException("Stub!"); }
+
+public java.util.SortedSet<E> tailSet(E fromElement) { throw new RuntimeException("Stub!"); }
+
+public java.util.Comparator<? super E> comparator() { throw new RuntimeException("Stub!"); }
+
+public E first() { throw new RuntimeException("Stub!"); }
+
+public E last() { throw new RuntimeException("Stub!"); }
+
+public E lower(E e) { throw new RuntimeException("Stub!"); }
+
+public E floor(E e) { throw new RuntimeException("Stub!"); }
+
+public E ceiling(E e) { throw new RuntimeException("Stub!"); }
+
+public E higher(E e) { throw new RuntimeException("Stub!"); }
+
+public E pollFirst() { throw new RuntimeException("Stub!"); }
+
+public E pollLast() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public void addFirst(E e) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public void addLast(E e) { throw new RuntimeException("Stub!"); }
+
+public java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+
+public java.util.Spliterator<E> spliterator() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/concurrent/ConcurrentSkipListMap.annotated.java b/ojluni/annotations/flagged_api/java/util/concurrent/ConcurrentSkipListMap.annotated.java
new file mode 100644
index 0000000..c0df9ef
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/concurrent/ConcurrentSkipListMap.annotated.java
@@ -0,0 +1,152 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+
+package java.util.concurrent;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ConcurrentSkipListMap<K, V> extends java.util.AbstractMap<K,V> implements java.util.concurrent.ConcurrentNavigableMap<K,V>, java.lang.Cloneable, java.io.Serializable {
+
+public ConcurrentSkipListMap() { throw new RuntimeException("Stub!"); }
+
+public ConcurrentSkipListMap(java.util.Comparator<? super K> comparator) { throw new RuntimeException("Stub!"); }
+
+public ConcurrentSkipListMap(java.util.Map<? extends K,? extends V> m) { throw new RuntimeException("Stub!"); }
+
+public ConcurrentSkipListMap(java.util.SortedMap<K,? extends V> m) { throw new RuntimeException("Stub!"); }
+
+public java.util.concurrent.ConcurrentSkipListMap<K,V> clone() { throw new RuntimeException("Stub!"); }
+
+public boolean containsKey(java.lang.Object key) { throw new RuntimeException("Stub!"); }
+
+public V get(java.lang.Object key) { throw new RuntimeException("Stub!"); }
+
+public V getOrDefault(java.lang.Object key, V defaultValue) { throw new RuntimeException("Stub!"); }
+
+public V put(K key, V value) { throw new RuntimeException("Stub!"); }
+
+public V remove(java.lang.Object key) { throw new RuntimeException("Stub!"); }
+
+public boolean containsValue(java.lang.Object value) { throw new RuntimeException("Stub!"); }
+
+public int size() { throw new RuntimeException("Stub!"); }
+
+public boolean isEmpty() { throw new RuntimeException("Stub!"); }
+
+public void clear() { throw new RuntimeException("Stub!"); }
+
+public V computeIfAbsent(K key, java.util.function.Function<? super K,? extends V> mappingFunction) { throw new RuntimeException("Stub!"); }
+
+public V computeIfPresent(K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction) { throw new RuntimeException("Stub!"); }
+
+public V compute(K key, java.util.function.BiFunction<? super K,? super V,? extends V> remappingFunction) { throw new RuntimeException("Stub!"); }
+
+public V merge(K key, V value, java.util.function.BiFunction<? super V,? super V,? extends V> remappingFunction) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<K> keySet() { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<K> navigableKeySet() { throw new RuntimeException("Stub!"); }
+
+public java.util.Collection<V> values() { throw new RuntimeException("Stub!"); }
+
+public java.util.Set<java.util.Map.Entry<K,V>> entrySet() { throw new RuntimeException("Stub!"); }
+
+public java.util.concurrent.ConcurrentNavigableMap<K,V> descendingMap() { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<K> descendingKeySet() { throw new RuntimeException("Stub!"); }
+
+public boolean equals(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public V putIfAbsent(K key, V value) { throw new RuntimeException("Stub!"); }
+
+public boolean remove(java.lang.Object key, java.lang.Object value) { throw new RuntimeException("Stub!"); }
+
+public boolean replace(K key, V oldValue, V newValue) { throw new RuntimeException("Stub!"); }
+
+public V replace(K key, V value) { throw new RuntimeException("Stub!"); }
+
+public java.util.Comparator<? super K> comparator() { throw new RuntimeException("Stub!"); }
+
+public K firstKey() { throw new RuntimeException("Stub!"); }
+
+public K lastKey() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public V putFirst(K k, V v) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public V putLast(K k, V v) { throw new RuntimeException("Stub!"); }
+
+public java.util.concurrent.ConcurrentNavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) { throw new RuntimeException("Stub!"); }
+
+public java.util.concurrent.ConcurrentNavigableMap<K,V> headMap(K toKey, boolean inclusive) { throw new RuntimeException("Stub!"); }
+
+public java.util.concurrent.ConcurrentNavigableMap<K,V> tailMap(K fromKey, boolean inclusive) { throw new RuntimeException("Stub!"); }
+
+public java.util.concurrent.ConcurrentNavigableMap<K,V> subMap(K fromKey, K toKey) { throw new RuntimeException("Stub!"); }
+
+public java.util.concurrent.ConcurrentNavigableMap<K,V> headMap(K toKey) { throw new RuntimeException("Stub!"); }
+
+public java.util.concurrent.ConcurrentNavigableMap<K,V> tailMap(K fromKey) { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> lowerEntry(K key) { throw new RuntimeException("Stub!"); }
+
+public K lowerKey(K key) { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> floorEntry(K key) { throw new RuntimeException("Stub!"); }
+
+public K floorKey(K key) { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> ceilingEntry(K key) { throw new RuntimeException("Stub!"); }
+
+public K ceilingKey(K key) { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> higherEntry(K key) { throw new RuntimeException("Stub!"); }
+
+public K higherKey(K key) { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> firstEntry() { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> lastEntry() { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> pollFirstEntry() { throw new RuntimeException("Stub!"); }
+
+public java.util.Map.Entry<K,V> pollLastEntry() { throw new RuntimeException("Stub!"); }
+
+public void forEach(java.util.function.BiConsumer<? super K,? super V> action) { throw new RuntimeException("Stub!"); }
+
+public void replaceAll(java.util.function.BiFunction<? super K,? super V,? extends V> function) { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/concurrent/ConcurrentSkipListSet.annotated.java b/ojluni/annotations/flagged_api/java/util/concurrent/ConcurrentSkipListSet.annotated.java
new file mode 100644
index 0000000..a2ef072
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/concurrent/ConcurrentSkipListSet.annotated.java
@@ -0,0 +1,112 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+
+package java.util.concurrent;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class ConcurrentSkipListSet<E> extends java.util.AbstractSet<E> implements java.util.NavigableSet<E>, java.lang.Cloneable, java.io.Serializable {
+
+public ConcurrentSkipListSet() { throw new RuntimeException("Stub!"); }
+
+public ConcurrentSkipListSet(java.util.Comparator<? super E> comparator) { throw new RuntimeException("Stub!"); }
+
+public ConcurrentSkipListSet(java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public ConcurrentSkipListSet(java.util.SortedSet<E> s) { throw new RuntimeException("Stub!"); }
+
+public java.util.concurrent.ConcurrentSkipListSet<E> clone() { throw new RuntimeException("Stub!"); }
+
+public int size() { throw new RuntimeException("Stub!"); }
+
+public boolean isEmpty() { throw new RuntimeException("Stub!"); }
+
+public boolean contains(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public boolean add(E e) { throw new RuntimeException("Stub!"); }
+
+public boolean remove(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public void clear() { throw new RuntimeException("Stub!"); }
+
+public java.util.Iterator<E> iterator() { throw new RuntimeException("Stub!"); }
+
+public java.util.Iterator<E> descendingIterator() { throw new RuntimeException("Stub!"); }
+
+public boolean equals(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public boolean removeAll(java.util.Collection<?> c) { throw new RuntimeException("Stub!"); }
+
+public E lower(E e) { throw new RuntimeException("Stub!"); }
+
+public E floor(E e) { throw new RuntimeException("Stub!"); }
+
+public E ceiling(E e) { throw new RuntimeException("Stub!"); }
+
+public E higher(E e) { throw new RuntimeException("Stub!"); }
+
+public E pollFirst() { throw new RuntimeException("Stub!"); }
+
+public E pollLast() { throw new RuntimeException("Stub!"); }
+
+public java.util.Comparator<? super E> comparator() { throw new RuntimeException("Stub!"); }
+
+public E first() { throw new RuntimeException("Stub!"); }
+
+public E last() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public void addFirst(E e) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public void addLast(E e) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<E> headSet(E toElement, boolean inclusive) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<E> tailSet(E fromElement, boolean inclusive) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<E> subSet(E fromElement, E toElement) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<E> headSet(E toElement) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<E> tailSet(E fromElement) { throw new RuntimeException("Stub!"); }
+
+public java.util.NavigableSet<E> descendingSet() { throw new RuntimeException("Stub!"); }
+
+public java.util.Spliterator<E> spliterator() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/flagged_api/java/util/concurrent/CopyOnWriteArrayList.annotated.java b/ojluni/annotations/flagged_api/java/util/concurrent/CopyOnWriteArrayList.annotated.java
new file mode 100644
index 0000000..73e65ea
--- /dev/null
+++ b/ojluni/annotations/flagged_api/java/util/concurrent/CopyOnWriteArrayList.annotated.java
@@ -0,0 +1,140 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group. Adapted and released, under explicit permission,
+ * from JDK ArrayList.java which carries the following copyright:
+ *
+ * Copyright 1997 by Sun Microsystems, Inc.,
+ * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
+ * All rights reserved.
+ */
+
+
+package java.util.concurrent;
+
+@SuppressWarnings({"unchecked", "deprecation", "all"})
+public class CopyOnWriteArrayList<E> implements java.util.List<E>, java.util.RandomAccess, java.lang.Cloneable, java.io.Serializable {
+
+public CopyOnWriteArrayList() { throw new RuntimeException("Stub!"); }
+
+public CopyOnWriteArrayList(java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public CopyOnWriteArrayList(E[] toCopyIn) { throw new RuntimeException("Stub!"); }
+
+public int size() { throw new RuntimeException("Stub!"); }
+
+public boolean isEmpty() { throw new RuntimeException("Stub!"); }
+
+public boolean contains(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public int indexOf(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public int indexOf(E e, int index) { throw new RuntimeException("Stub!"); }
+
+public int lastIndexOf(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public int lastIndexOf(E e, int index) { throw new RuntimeException("Stub!"); }
+
+public java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+
+public java.lang.Object[] toArray() { throw new RuntimeException("Stub!"); }
+
+public <T> T[] toArray(T[] a) { throw new RuntimeException("Stub!"); }
+
+public E get(int index) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public E getFirst() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public E getLast() { throw new RuntimeException("Stub!"); }
+
+public E set(int index, E element) { throw new RuntimeException("Stub!"); }
+
+public boolean add(E e) { throw new RuntimeException("Stub!"); }
+
+public void add(int index, E element) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public void addFirst(E e) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public void addLast(E e) { throw new RuntimeException("Stub!"); }
+
+public E remove(int index) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public E removeFirst() { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public E removeLast() { throw new RuntimeException("Stub!"); }
+
+public boolean remove(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public boolean addIfAbsent(E e) { throw new RuntimeException("Stub!"); }
+
+public boolean containsAll(java.util.Collection<?> c) { throw new RuntimeException("Stub!"); }
+
+public boolean removeAll(java.util.Collection<?> c) { throw new RuntimeException("Stub!"); }
+
+public boolean retainAll(java.util.Collection<?> c) { throw new RuntimeException("Stub!"); }
+
+public int addAllAbsent(java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public void clear() { throw new RuntimeException("Stub!"); }
+
+public boolean addAll(java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public boolean addAll(int index, java.util.Collection<? extends E> c) { throw new RuntimeException("Stub!"); }
+
+public void forEach(java.util.function.Consumer<? super E> action) { throw new RuntimeException("Stub!"); }
+
+public boolean removeIf(java.util.function.Predicate<? super E> filter) { throw new RuntimeException("Stub!"); }
+
+public void replaceAll(java.util.function.UnaryOperator<E> operator) { throw new RuntimeException("Stub!"); }
+
+public void sort(java.util.Comparator<? super E> c) { throw new RuntimeException("Stub!"); }
+
+public java.lang.String toString() { throw new RuntimeException("Stub!"); }
+
+public boolean equals(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+
+public int hashCode() { throw new RuntimeException("Stub!"); }
+
+public java.util.Iterator<E> iterator() { throw new RuntimeException("Stub!"); }
+
+public java.util.ListIterator<E> listIterator() { throw new RuntimeException("Stub!"); }
+
+public java.util.ListIterator<E> listIterator(int index) { throw new RuntimeException("Stub!"); }
+
+public java.util.Spliterator<E> spliterator() { throw new RuntimeException("Stub!"); }
+
+public java.util.List<E> subList(int fromIndex, int toIndex) { throw new RuntimeException("Stub!"); }
+
+@android.annotation.FlaggedApi(com.android.libcore.Flags.FLAG_V_APIS)
+public java.util.List<E> reversed() { throw new RuntimeException("Stub!"); }
+}
+
diff --git a/ojluni/annotations/sdk/nullability/java/util/ArrayList.annotated.java b/ojluni/annotations/sdk/nullability/java/util/ArrayList.annotated.java
index 255c4be..aa6ee9d 100644
--- a/ojluni/annotations/sdk/nullability/java/util/ArrayList.annotated.java
+++ b/ojluni/annotations/sdk/nullability/java/util/ArrayList.annotated.java
@@ -64,6 +64,18 @@
public boolean add(@libcore.util.NullFromTypeParam E e) { throw new RuntimeException("Stub!"); }
+public void addFirst(@libcore.util.NullFromTypeParam E e) { throw new RuntimeException("Stub!"); }
+
+public void addLast(@libcore.util.NullFromTypeParam E e) { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NullFromTypeParam public E getFirst() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NullFromTypeParam public E getLast() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NullFromTypeParam public E removeFirst() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NullFromTypeParam public E removeLast() { throw new RuntimeException("Stub!"); }
+
public void add(int index, @libcore.util.NullFromTypeParam E element) { throw new RuntimeException("Stub!"); }
@libcore.util.NullFromTypeParam public E remove(int index) { throw new RuntimeException("Stub!"); }
diff --git a/ojluni/annotations/sdk/nullability/java/util/Collections.annotated.java b/ojluni/annotations/sdk/nullability/java/util/Collections.annotated.java
index 3e3e636..260b69f 100644
--- a/ojluni/annotations/sdk/nullability/java/util/Collections.annotated.java
+++ b/ojluni/annotations/sdk/nullability/java/util/Collections.annotated.java
@@ -49,6 +49,8 @@
public static void shuffle(@libcore.util.NonNull java.util.List<?> list, @libcore.util.NonNull java.util.Random rnd) { throw new RuntimeException("Stub!"); }
+public static void shuffle(@libcore.util.NonNull java.util.List<?> list, @libcore.util.NonNull java.util.random.RandomGenerator rnd) { throw new RuntimeException("Stub!"); }
+
public static void swap(@libcore.util.NonNull java.util.List<?> list, int i, int j) { throw new RuntimeException("Stub!"); }
public static <T> void fill(@libcore.util.NonNull java.util.List<? super @libcore.util.NullFromTypeParam T> list, @libcore.util.NullFromTypeParam T obj) { throw new RuntimeException("Stub!"); }
diff --git a/ojluni/annotations/sdk/nullability/java/util/Deque.annotated.java b/ojluni/annotations/sdk/nullability/java/util/Deque.annotated.java
index d93d5a2..af5cc34 100644
--- a/ojluni/annotations/sdk/nullability/java/util/Deque.annotated.java
+++ b/ojluni/annotations/sdk/nullability/java/util/Deque.annotated.java
@@ -93,4 +93,6 @@
@libcore.util.NonNull public java.util.Iterator<@libcore.util.NullFromTypeParam E> iterator();
@libcore.util.NonNull public java.util.Iterator<@libcore.util.NullFromTypeParam E> descendingIterator();
+
+@libcore.util.NonNull public default java.util.Deque<E> reversed() { throw new RuntimeException("Stub!"); }
}
diff --git a/ojluni/annotations/sdk/nullability/java/util/HashMap.annotated.java b/ojluni/annotations/sdk/nullability/java/util/HashMap.annotated.java
index 3bcc489..71cec4a 100644
--- a/ojluni/annotations/sdk/nullability/java/util/HashMap.annotated.java
+++ b/ojluni/annotations/sdk/nullability/java/util/HashMap.annotated.java
@@ -85,4 +85,7 @@
public void replaceAll(@libcore.util.NonNull java.util.function.BiFunction<? super @libcore.util.NullFromTypeParam K,? super @libcore.util.NullFromTypeParam V,? extends @libcore.util.NullFromTypeParam V> function) { throw new RuntimeException("Stub!"); }
@libcore.util.NonNull public java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NonNull public static <K, V> java.util.HashMap<K, V> newHashMap(int numMappings) { throw new RuntimeException("Stub!"); }
+
}
diff --git a/ojluni/annotations/sdk/nullability/java/util/HashSet.annotated.java b/ojluni/annotations/sdk/nullability/java/util/HashSet.annotated.java
index c099118..3b044c2 100644
--- a/ojluni/annotations/sdk/nullability/java/util/HashSet.annotated.java
+++ b/ojluni/annotations/sdk/nullability/java/util/HashSet.annotated.java
@@ -55,4 +55,7 @@
@libcore.util.NonNull public java.lang.Object clone() { throw new RuntimeException("Stub!"); }
@libcore.util.NonNull public java.util.Spliterator<@libcore.util.NullFromTypeParam E> spliterator() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NonNull public static <T> java.util.HashSet<T> newHashSet(int numElements) { throw new RuntimeException("Stub!"); }
+
}
diff --git a/ojluni/annotations/sdk/nullability/java/util/LinkedList.annotated.java b/ojluni/annotations/sdk/nullability/java/util/LinkedList.annotated.java
index f85afd1..6bbbda7 100644
--- a/ojluni/annotations/sdk/nullability/java/util/LinkedList.annotated.java
+++ b/ojluni/annotations/sdk/nullability/java/util/LinkedList.annotated.java
@@ -113,4 +113,6 @@
public <T> T @libcore.util.NonNull [] toArray(T @libcore.util.NonNull [] a) { throw new RuntimeException("Stub!"); }
@libcore.util.NonNull public java.util.Spliterator<@libcore.util.NullFromTypeParam E> spliterator() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NonNull public default java.util.LinkedList<E> reversed() { throw new RuntimeException("Stub!"); }
}
diff --git a/ojluni/annotations/sdk/nullability/java/util/List.annotated.java b/ojluni/annotations/sdk/nullability/java/util/List.annotated.java
index 9583d18..c1fc44c 100644
--- a/ojluni/annotations/sdk/nullability/java/util/List.annotated.java
+++ b/ojluni/annotations/sdk/nullability/java/util/List.annotated.java
@@ -113,4 +113,19 @@
@libcore.util.NonNull public static <E> java.util.List<@libcore.util.NonNull E> of(E @libcore.util.NonNull ... elements) { throw new RuntimeException("Stub!"); }
@libcore.util.NonNull public static <E> java.util.List<@libcore.util.NonNull E> copyOf(@libcore.util.NonNull java.util.Collection<? extends E> coll) { throw new RuntimeException("Stub!"); }
+
+public default void addFirst(@libcore.util.NullFromTypeParam E e) { throw new RuntimeException("Stub!"); }
+
+public default void addLast(@libcore.util.NullFromTypeParam E e) { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NullFromTypeParam public default E getFirst() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NullFromTypeParam public default E getLast() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NullFromTypeParam public default E removeFirst() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NullFromTypeParam public default E removeLast() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NonNull public default java.util.List<E> reversed() { throw new RuntimeException("Stub!"); }
+
}
\ No newline at end of file
diff --git a/ojluni/annotations/sdk/nullability/java/util/NavigableMap.annotated.java b/ojluni/annotations/sdk/nullability/java/util/NavigableMap.annotated.java
index e3f4afb..101b0c7 100644
--- a/ojluni/annotations/sdk/nullability/java/util/NavigableMap.annotated.java
+++ b/ojluni/annotations/sdk/nullability/java/util/NavigableMap.annotated.java
@@ -81,4 +81,7 @@
@libcore.util.NonNull public java.util.SortedMap<@libcore.util.NullFromTypeParam K, @libcore.util.NullFromTypeParam V> headMap(@libcore.util.NullFromTypeParam K toKey);
@libcore.util.NonNull public java.util.SortedMap<@libcore.util.NullFromTypeParam K, @libcore.util.NullFromTypeParam V> tailMap(@libcore.util.NullFromTypeParam K fromKey);
+
+@libcore.util.NonNull public default java.util.NavigableMap<K, V> reversed() { throw new RuntimeException("Stub!"); }
+
}
diff --git a/ojluni/annotations/sdk/nullability/java/util/SortedMap.annotated.java b/ojluni/annotations/sdk/nullability/java/util/SortedMap.annotated.java
index 9d68839..ab2a3d1 100644
--- a/ojluni/annotations/sdk/nullability/java/util/SortedMap.annotated.java
+++ b/ojluni/annotations/sdk/nullability/java/util/SortedMap.annotated.java
@@ -47,4 +47,11 @@
@libcore.util.NonNull public java.util.Collection<@libcore.util.NullFromTypeParam V> values();
@libcore.util.NonNull public java.util.Set<java.util.Map.@libcore.util.NonNull Entry<@libcore.util.NullFromTypeParam K, @libcore.util.NullFromTypeParam V>> entrySet();
+
+@libcore.util.Nullable public default V putFirst(@libcore.util.NullFromTypeParam K k, @libcore.util.NullFromTypeParam V v) { throw new RuntimeException("Stub!"); }
+
+@libcore.util.Nullable public default V putLast(@libcore.util.NullFromTypeParam K k, @libcore.util.NullFromTypeParam V v) { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NonNull public default java.util.SortedMap<K,V> reversed() { throw new RuntimeException("Stub!"); }
+
}
diff --git a/ojluni/annotations/sdk/nullability/java/util/TreeMap.annotated.java b/ojluni/annotations/sdk/nullability/java/util/TreeMap.annotated.java
index 87f1f20..61c606e 100644
--- a/ojluni/annotations/sdk/nullability/java/util/TreeMap.annotated.java
+++ b/ojluni/annotations/sdk/nullability/java/util/TreeMap.annotated.java
@@ -118,4 +118,9 @@
public void forEach(@libcore.util.NonNull java.util.function.BiConsumer<? super @libcore.util.NullFromTypeParam K,? super @libcore.util.NullFromTypeParam V> action) { throw new RuntimeException("Stub!"); }
public void replaceAll(@libcore.util.NonNull java.util.function.BiFunction<? super @libcore.util.NullFromTypeParam K,? super @libcore.util.NullFromTypeParam V,? extends @libcore.util.NullFromTypeParam V> function) { throw new RuntimeException("Stub!"); }
+
+@libcore.util.Nullable public V putFirst(@libcore.util.NullFromTypeParam K k, @libcore.util.NullFromTypeParam V v) { throw new RuntimeException("Stub!"); }
+
+@libcore.util.Nullable public V putLast(@libcore.util.NullFromTypeParam K k, @libcore.util.NullFromTypeParam V v) { throw new RuntimeException("Stub!"); }
+
}
diff --git a/ojluni/annotations/sdk/nullability/java/util/concurrent/CopyOnWriteArrayList.annotated.java b/ojluni/annotations/sdk/nullability/java/util/concurrent/CopyOnWriteArrayList.annotated.java
index 57ab75c..638448e 100644
--- a/ojluni/annotations/sdk/nullability/java/util/concurrent/CopyOnWriteArrayList.annotated.java
+++ b/ojluni/annotations/sdk/nullability/java/util/concurrent/CopyOnWriteArrayList.annotated.java
@@ -122,4 +122,19 @@
@libcore.util.NonNull public java.util.Spliterator<@libcore.util.NullFromTypeParam E> spliterator() { throw new RuntimeException("Stub!"); }
@libcore.util.NonNull public java.util.List<@libcore.util.NullFromTypeParam E> subList(int fromIndex, int toIndex) { throw new RuntimeException("Stub!"); }
+
+public default void addFirst(@libcore.util.NullFromTypeParam E e) { throw new RuntimeException("Stub!"); }
+
+public default void addLast(@libcore.util.NullFromTypeParam E e) { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NullFromTypeParam public default E getFirst() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NullFromTypeParam public default E getLast() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NullFromTypeParam public default E removeFirst() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NullFromTypeParam public default E removeLast() { throw new RuntimeException("Stub!"); }
+
+@libcore.util.NonNull public default java.util.List<E> reversed() { throw new RuntimeException("Stub!"); }
+
}
diff --git a/ojluni/src/main/java/java/util/ArrayList.java b/ojluni/src/main/java/java/util/ArrayList.java
index e88e98a..a418e64 100644
--- a/ojluni/src/main/java/java/util/ArrayList.java
+++ b/ojluni/src/main/java/java/util/ArrayList.java
@@ -440,7 +440,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
public E getFirst() {
if (size == 0) {
@@ -455,7 +454,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
public E getLast() {
int last = size - 1;
@@ -533,7 +531,6 @@
* {@inheritDoc}
*
* @since 21
- * @hide
*/
public void addFirst(E element) {
add(0, element);
@@ -543,7 +540,6 @@
* {@inheritDoc}
*
* @since 21
- * @hide
*/
public void addLast(E element) {
add(element);
@@ -573,7 +569,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
public E removeFirst() {
if (size == 0) {
@@ -591,7 +586,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
public E removeLast() {
int last = size - 1;
diff --git a/ojluni/src/main/java/java/util/Collections.java b/ojluni/src/main/java/java/util/Collections.java
index 6b9d207..1b164e2 100644
--- a/ojluni/src/main/java/java/util/Collections.java
+++ b/ojluni/src/main/java/java/util/Collections.java
@@ -522,7 +522,6 @@
* @throws UnsupportedOperationException if the specified list or its
* list-iterator does not support the {@code set} operation.
* @since 21
- * @hide
*/
@SuppressWarnings({"rawtypes", "unchecked"})
public static void shuffle(List<?> list, RandomGenerator rnd) {
diff --git a/ojluni/src/main/java/java/util/Deque.java b/ojluni/src/main/java/java/util/Deque.java
index cf17d28..0998f02 100644
--- a/ojluni/src/main/java/java/util/Deque.java
+++ b/ojluni/src/main/java/java/util/Deque.java
@@ -627,7 +627,6 @@
*
* @return a reverse-ordered view of this collection, as a {@code Deque}
* @since 21
- * @hide
*/
default Deque<E> reversed() {
return ReverseOrderDequeView.of(this);
diff --git a/ojluni/src/main/java/java/util/HashMap.java b/ojluni/src/main/java/java/util/HashMap.java
index eea67e0..b1996b5 100644
--- a/ojluni/src/main/java/java/util/HashMap.java
+++ b/ojluni/src/main/java/java/util/HashMap.java
@@ -2574,7 +2574,6 @@
* @return the newly created map
* @throws IllegalArgumentException if numMappings is negative
* @since 19
- * @hide
*/
public static <K, V> HashMap<K, V> newHashMap(int numMappings) {
if (numMappings < 0) {
diff --git a/ojluni/src/main/java/java/util/HashSet.java b/ojluni/src/main/java/java/util/HashSet.java
index affcd15..e59bf7b 100644
--- a/ojluni/src/main/java/java/util/HashSet.java
+++ b/ojluni/src/main/java/java/util/HashSet.java
@@ -392,7 +392,6 @@
* @return the newly created set
* @throws IllegalArgumentException if numElements is negative
* @since 19
- * @hide
*/
public static <T> HashSet<T> newHashSet(int numElements) {
if (numElements < 0) {
diff --git a/ojluni/src/main/java/java/util/LinkedHashMap.java b/ojluni/src/main/java/java/util/LinkedHashMap.java
index f787738..c0292a9 100644
--- a/ojluni/src/main/java/java/util/LinkedHashMap.java
+++ b/ojluni/src/main/java/java/util/LinkedHashMap.java
@@ -406,7 +406,6 @@
* so that it is first in encounter order.
*
* @since 21
- * @hide
*/
public V putFirst(K k, V v) {
try {
@@ -424,7 +423,6 @@
* so that it is last in encounter order.
*
* @since 21
- * @hide
*/
public V putLast(K k, V v) {
try {
@@ -1113,7 +1111,6 @@
* @return the newly created map
* @throws IllegalArgumentException if numMappings is negative
* @since 19
- * @hide
*/
public static <K, V> LinkedHashMap<K, V> newLinkedHashMap(int numMappings) {
if (numMappings < 0) {
diff --git a/ojluni/src/main/java/java/util/LinkedHashSet.java b/ojluni/src/main/java/java/util/LinkedHashSet.java
index a74f485..6280543 100644
--- a/ojluni/src/main/java/java/util/LinkedHashSet.java
+++ b/ojluni/src/main/java/java/util/LinkedHashSet.java
@@ -217,7 +217,6 @@
* @return the newly created set
* @throws IllegalArgumentException if numElements is negative
* @since 19
- * @hide
*/
public static <T> LinkedHashSet<T> newLinkedHashSet(int numElements) {
if (numElements < 0) {
@@ -238,7 +237,6 @@
* first in encounter order.
*
* @since 21
- * @hide
*/
public void addFirst(E e) {
map().putFirst(e, PRESENT);
@@ -251,7 +249,6 @@
* last in encounter order.
*
* @since 21
- * @hide
*/
public void addLast(E e) {
map().putLast(e, PRESENT);
@@ -262,7 +259,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
public E getFirst() {
return map().sequencedKeySet().getFirst();
@@ -273,7 +269,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
public E getLast() {
return map().sequencedKeySet().getLast();
@@ -284,7 +279,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
public E removeFirst() {
return map().sequencedKeySet().removeFirst();
@@ -295,7 +289,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
public E removeLast() {
return map().sequencedKeySet().removeLast();
diff --git a/ojluni/src/main/java/java/util/LinkedList.java b/ojluni/src/main/java/java/util/LinkedList.java
index b33ef32..d7c67c9 100644
--- a/ojluni/src/main/java/java/util/LinkedList.java
+++ b/ojluni/src/main/java/java/util/LinkedList.java
@@ -1281,7 +1281,6 @@
*
* @return {@inheritDoc}
* @since 21
- * @hide
*/
public LinkedList<E> reversed() {
return new ReverseOrderLinkedListView<>(this, super.reversed(), Deque.super.reversed());
diff --git a/ojluni/src/main/java/java/util/List.java b/ojluni/src/main/java/java/util/List.java
index 945a0a1..ad5f4ee 100644
--- a/ojluni/src/main/java/java/util/List.java
+++ b/ojluni/src/main/java/java/util/List.java
@@ -810,7 +810,6 @@
* @throws NullPointerException {@inheritDoc}
* @throws UnsupportedOperationException {@inheritDoc}
* @since 21
- * @hide
*/
default void addFirst(E e) {
this.add(0, e);
@@ -825,7 +824,6 @@
* @throws NullPointerException {@inheritDoc}
* @throws UnsupportedOperationException {@inheritDoc}
* @since 21
- * @hide
*/
default void addLast(E e) {
this.add(e);
@@ -840,7 +838,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
default E getFirst() {
if (this.isEmpty()) {
@@ -859,7 +856,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
default E getLast() {
if (this.isEmpty()) {
@@ -879,7 +875,6 @@
* @throws NoSuchElementException {@inheritDoc}
* @throws UnsupportedOperationException {@inheritDoc}
* @since 21
- * @hide
*/
default E removeFirst() {
if (this.isEmpty()) {
@@ -899,7 +894,6 @@
* @throws NoSuchElementException {@inheritDoc}
* @throws UnsupportedOperationException {@inheritDoc}
* @since 21
- * @hide
*/
default E removeLast() {
if (this.isEmpty()) {
@@ -924,7 +918,6 @@
*
* @return a reverse-ordered view of this collection, as a {@code List}
* @since 21
- * @hide
*/
default List<E> reversed() {
return ReverseOrderListView.of(this, true); // we must assume it's modifiable
diff --git a/ojluni/src/main/java/java/util/NavigableMap.java b/ojluni/src/main/java/java/util/NavigableMap.java
index c88ce73..98545ab 100644
--- a/ojluni/src/main/java/java/util/NavigableMap.java
+++ b/ojluni/src/main/java/java/util/NavigableMap.java
@@ -441,7 +441,6 @@
*
* @return a reverse-ordered view of this map, as a {@code NavigableMap}
* @since 21
- * @hide
*/
default NavigableMap<K, V> reversed() {
return this.descendingMap();
diff --git a/ojluni/src/main/java/java/util/NavigableSet.java b/ojluni/src/main/java/java/util/NavigableSet.java
index a31699e..4dacd1e 100644
--- a/ojluni/src/main/java/java/util/NavigableSet.java
+++ b/ojluni/src/main/java/java/util/NavigableSet.java
@@ -331,7 +331,6 @@
* @throws NoSuchElementException {@inheritDoc}
* @throws UnsupportedOperationException {@inheritDoc}
* @since 21
- * @hide
*/
default E removeFirst() {
if (this.isEmpty()) {
@@ -351,7 +350,6 @@
* @throws NoSuchElementException {@inheritDoc}
* @throws UnsupportedOperationException {@inheritDoc}
* @since 21
- * @hide
*/
default E removeLast() {
if (this.isEmpty()) {
@@ -372,7 +370,6 @@
*
* @return a reverse-ordered view of this collection, as a {@code NavigableSet}
* @since 21
- * @hide
*/
default NavigableSet<E> reversed() {
return this.descendingSet();
diff --git a/ojluni/src/main/java/java/util/SortedMap.java b/ojluni/src/main/java/java/util/SortedMap.java
index d6b5e67..4441bd7 100644
--- a/ojluni/src/main/java/java/util/SortedMap.java
+++ b/ojluni/src/main/java/java/util/SortedMap.java
@@ -292,7 +292,6 @@
*
* @throws UnsupportedOperationException always
* @since 21
- * @hide
*/
default V putFirst(K k, V v) {
throw new UnsupportedOperationException();
@@ -308,7 +307,6 @@
*
* @throws UnsupportedOperationException always
* @since 21
- * @hide
*/
default V putLast(K k, V v) {
throw new UnsupportedOperationException();
@@ -329,7 +327,6 @@
*
* @return a reverse-ordered view of this map, as a {@code SortedMap}
* @since 21
- * @hide
*/
default SortedMap<K, V> reversed() {
return ReverseOrderSortedMapView.of(this);
diff --git a/ojluni/src/main/java/java/util/SortedSet.java b/ojluni/src/main/java/java/util/SortedSet.java
index d1f486e..3b46124 100644
--- a/ojluni/src/main/java/java/util/SortedSet.java
+++ b/ojluni/src/main/java/java/util/SortedSet.java
@@ -274,7 +274,6 @@
*
* @throws UnsupportedOperationException always
* @since 21
- * @hide
*/
default void addFirst(E e) {
throw new UnsupportedOperationException();
@@ -290,7 +289,6 @@
*
* @throws UnsupportedOperationException always
* @since 21
- * @hide
*/
default void addLast(E e) {
throw new UnsupportedOperationException();
@@ -304,7 +302,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
default E getFirst() {
return this.first();
@@ -318,7 +315,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
default E getLast() {
return this.last();
@@ -335,7 +331,6 @@
* @throws NoSuchElementException {@inheritDoc}
* @throws UnsupportedOperationException {@inheritDoc}
* @since 21
- * @hide
*/
default E removeFirst() {
E e = this.first();
@@ -354,7 +349,6 @@
* @throws NoSuchElementException {@inheritDoc}
* @throws UnsupportedOperationException {@inheritDoc}
* @since 21
- * @hide
*/
default E removeLast() {
E e = this.last();
@@ -377,7 +371,6 @@
*
* @return a reverse-ordered view of this collection, as a {@code SortedSet}
* @since 21
- * @hide
*/
default SortedSet<E> reversed() {
return ReverseOrderSortedSetView.of(this);
diff --git a/ojluni/src/main/java/java/util/TreeMap.java b/ojluni/src/main/java/java/util/TreeMap.java
index cb51fb3..74cba6b 100644
--- a/ojluni/src/main/java/java/util/TreeMap.java
+++ b/ojluni/src/main/java/java/util/TreeMap.java
@@ -317,7 +317,6 @@
*
* @throws UnsupportedOperationException always
* @since 21
- * @hide
*/
public V putFirst(K k, V v) {
throw new UnsupportedOperationException();
@@ -330,7 +329,6 @@
*
* @throws UnsupportedOperationException always
* @since 21
- * @hide
*/
public V putLast(K k, V v) {
throw new UnsupportedOperationException();
diff --git a/ojluni/src/main/java/java/util/TreeSet.java b/ojluni/src/main/java/java/util/TreeSet.java
index 81e97f3..a68c157 100644
--- a/ojluni/src/main/java/java/util/TreeSet.java
+++ b/ojluni/src/main/java/java/util/TreeSet.java
@@ -471,7 +471,6 @@
*
* @throws UnsupportedOperationException always
* @since 21
- * @hide
*/
public void addFirst(E e) {
throw new UnsupportedOperationException();
@@ -484,7 +483,6 @@
*
* @throws UnsupportedOperationException always
* @since 21
- * @hide
*/
public void addLast(E e) {
throw new UnsupportedOperationException();
diff --git a/ojluni/src/main/java/java/util/concurrent/ConcurrentSkipListMap.java b/ojluni/src/main/java/java/util/concurrent/ConcurrentSkipListMap.java
index cf89bf9..bccbccf 100644
--- a/ojluni/src/main/java/java/util/concurrent/ConcurrentSkipListMap.java
+++ b/ojluni/src/main/java/java/util/concurrent/ConcurrentSkipListMap.java
@@ -1877,7 +1877,6 @@
*
* @throws UnsupportedOperationException always
* @since 21
- * @hide
*/
public V putFirst(K k, V v) {
throw new UnsupportedOperationException();
@@ -1890,7 +1889,6 @@
*
* @throws UnsupportedOperationException always
* @since 21
- * @hide
*/
public V putLast(K k, V v) {
throw new UnsupportedOperationException();
diff --git a/ojluni/src/main/java/java/util/concurrent/ConcurrentSkipListSet.java b/ojluni/src/main/java/java/util/concurrent/ConcurrentSkipListSet.java
index b5c1c7f..0db76e0 100644
--- a/ojluni/src/main/java/java/util/concurrent/ConcurrentSkipListSet.java
+++ b/ojluni/src/main/java/java/util/concurrent/ConcurrentSkipListSet.java
@@ -410,7 +410,6 @@
*
* @throws UnsupportedOperationException always
* @since 21
- * @hide
*/
public void addFirst(E e) {
throw new UnsupportedOperationException();
@@ -423,7 +422,6 @@
*
* @throws UnsupportedOperationException always
* @since 21
- * @hide
*/
public void addLast(E e) {
throw new UnsupportedOperationException();
diff --git a/ojluni/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java b/ojluni/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java
index e2293fa..4c83326 100644
--- a/ojluni/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java
+++ b/ojluni/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java
@@ -412,7 +412,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
public E getFirst() {
Object[] es = getArray();
@@ -427,7 +426,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
public E getLast() {
Object[] es = getArray();
@@ -507,7 +505,6 @@
* {@inheritDoc}
*
* @since 21
- * @hide
*/
public void addFirst(E e) {
add(0, e);
@@ -517,7 +514,6 @@
* {@inheritDoc}
*
* @since 21
- * @hide
*/
public void addLast(E e) {
synchronized (lock) {
@@ -557,7 +553,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
public E removeFirst() {
synchronized (lock) {
@@ -573,7 +568,6 @@
*
* @throws NoSuchElementException {@inheritDoc}
* @since 21
- * @hide
*/
public E removeLast() {
synchronized (lock) {
@@ -1741,7 +1735,6 @@
* the same restrictions as those of this list.
*
* @since 21
- * @hide
*/
public List<E> reversed() {
return new Reversed<>(this, lock);
diff --git a/openjdk_java_files.bp b/openjdk_java_files.bp
index 3ae206d..8f2e696 100644
--- a/openjdk_java_files.bp
+++ b/openjdk_java_files.bp
@@ -960,6 +960,9 @@
"ojluni/src/main/java/java/util/OptionalLong.java",
"ojluni/src/main/java/java/util/OptionalDouble.java",
"ojluni/src/main/java/java/util/PrimitiveIterator.java",
+ "ojluni/src/main/java/java/util/SequencedCollection.java",
+ "ojluni/src/main/java/java/util/SequencedMap.java",
+ "ojluni/src/main/java/java/util/SequencedSet.java",
"ojluni/src/main/java/java/util/StringJoiner.java",
"ojluni/src/main/java/java/util/Tripwire.java",
"ojluni/src/main/java/java/util/DoubleSummaryStatistics.java",
@@ -1525,9 +1528,6 @@
"ojluni/src/main/java/java/util/LocaleISOData.java",
"ojluni/src/main/java/java/util/KeyValueHolder.java",
"ojluni/src/main/java/java/util/JapaneseImperialCalendar.java",
- "ojluni/src/main/java/java/util/SequencedCollection.java",
- "ojluni/src/main/java/java/util/SequencedMap.java",
- "ojluni/src/main/java/java/util/SequencedSet.java",
"ojluni/src/main/java/java/util/ReverseOrderDequeView.java",
"ojluni/src/main/java/java/util/ReverseOrderListView.java",
"ojluni/src/main/java/java/util/ReverseOrderSortedMapView.java",
diff --git a/tools/ojluni-annotations/generate_flagged_api_files.sh b/tools/ojluni-annotations/generate_flagged_api_files.sh
index b9f74b9..f0cf461 100755
--- a/tools/ojluni-annotations/generate_flagged_api_files.sh
+++ b/tools/ojluni-annotations/generate_flagged_api_files.sh
@@ -25,11 +25,11 @@
if [[ "${CLASS:0:5}" == "java." || "${CLASS:0:6}" == "javax." || "${CLASS:0:4}" == "sun." \
|| "${CLASS:0:4}" == "jdk." || "${CLASS:0:8}" == "com.sun." ]];
then
- unzip out/soong/.intermediates/libcore/openjdk-sdk-stubs-no-javadoc/android_common/everything/openjdk-sdk-stubs-no-javadoc-stubs.srcjar \
+ unzip out/soong/.intermediates/libcore/openjdk-sdk-stubs-no-javadoc/android_common/exportable/openjdk-sdk-stubs-no-javadoc-stubs.srcjar \
"${FILE}".java -d libcore/ojluni/annotations/flagged_api/
mv libcore/ojluni/annotations/flagged_api/"$FILE".java libcore/ojluni/annotations/flagged_api/"$FILE".annotated.java
else
- unzip out/soong/.intermediates/libcore/libart-sdk-stubs-no-javadoc/android_common/everything/libart-sdk-stubs-no-javadoc-stubs.srcjar \
+ unzip out/soong/.intermediates/libcore/libart-sdk-stubs-no-javadoc/android_common/exportable/libart-sdk-stubs-no-javadoc-stubs.srcjar \
"${FILE}".java -d libcore/luni/annotations/flagged_api/
mv libcore/luni/annotations/flagged_api/"$FILE".java libcore/luni/annotations/flagged_api/"$FILE".annotated.java
fi
diff --git a/tools/ojluni-annotations/generate_nullability_files.sh b/tools/ojluni-annotations/generate_nullability_files.sh
new file mode 100755
index 0000000..b28191c
--- /dev/null
+++ b/tools/ojluni-annotations/generate_nullability_files.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Copyright (C) 2023 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Exit this shell script when a command fails.
+set -e
+
+cd "${ANDROID_BUILD_TOP}"
+build/soong/soong_ui.bash --make-mode openjdk-sdk-stubs-no-javadoc libart-sdk-stubs-no-javadoc
+for CLASS in "$@";
+do
+ FILE=${CLASS//./\/}
+ unzip out/soong/.intermediates/libcore/openjdk-sdk-stubs-no-javadoc/android_common/exportable/openjdk-sdk-stubs-no-javadoc-stubs.srcjar \
+ "${FILE}".java -d libcore/ojluni/annotations/sdk/nullability/
+ mv libcore/ojluni/annotations/sdk/nullability/"$FILE".java libcore/ojluni/annotations/sdk/nullability/"$FILE".annotated.java
+done
