Merge "Add java.lang.Iterable.spliterator() and supporting classes."
diff --git a/luni/src/test/java/libcore/java/lang/SystemTest.java b/luni/src/test/java/libcore/java/lang/SystemTest.java
index ff155d3..f16c380 100644
--- a/luni/src/test/java/libcore/java/lang/SystemTest.java
+++ b/luni/src/test/java/libcore/java/lang/SystemTest.java
@@ -21,6 +21,8 @@
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
+import java.lang.SecurityException;
+import java.lang.SecurityManager;
import java.util.Formatter;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicBoolean;
@@ -236,4 +238,16 @@
assertEquals(userDir, System.getProperty("user.dir"));
assertNull(System.getProperty("p1"));
}
+
+ public void testSystem_setSecurityManager_null_noException() {
+ System.setSecurityManager(null);
+ }
+
+ public void testSystem_setSecurityManager_notNull_throwsException() {
+ try {
+ System.setSecurityManager(new SecurityManager());
+ fail("Expected " + SecurityException.class.getName());
+ } catch (SecurityException expected) {
+ }
+ }
}
diff --git a/luni/src/test/java/libcore/java/util/StringJoinerTest.java b/luni/src/test/java/libcore/java/util/StringJoinerTest.java
new file mode 100644
index 0000000..cad4103
--- /dev/null
+++ b/luni/src/test/java/libcore/java/util/StringJoinerTest.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2016 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 junit.framework.TestCase;
+
+import java.util.StringJoiner;
+
+public class StringJoinerTest extends TestCase {
+
+ private static final String[] WEEKDAYS = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
+ private static final String EXPECTED = "[Mon,Tue,Wed,Thu,Fri,Sat,Sun]";
+
+ public void testConstructorNull() {
+ try {
+ new StringJoiner(null);
+ fail();
+ } catch (NullPointerException expected) {}
+
+ try {
+ new StringJoiner(null, "[", "]");
+ fail();
+ } catch (NullPointerException expected) {}
+
+ try {
+ new StringJoiner(",", null, null);
+ fail();
+ } catch (NullPointerException expected) {}
+ }
+
+ public void testAddString() {
+ StringJoiner sj = new StringJoiner(",", "[", "]");
+
+ for (int i = 0; i < WEEKDAYS.length; ++i) {
+ sj.add(WEEKDAYS[i]);
+ int expectedLength = 2 /* prefix and postfix */
+ + 3 * (i + 1) /* length of elements */
+ + i /* length of separators, one less than number of elements */;
+ assertEquals(expectedLength, sj.length());
+ }
+ assertEquals(EXPECTED, sj.toString());
+ }
+
+ public void testAddStringBuilder() {
+ StringJoiner sj = new StringJoiner(",", "[", "]");
+
+ for (int i = 0; i < WEEKDAYS.length; ++i) {
+ sj.add(new StringBuilder(WEEKDAYS[i]));
+ int expectedLength = 2 /* prefix and postfix */
+ + 3 * (i + 1) /* length of elements */
+ + i /* length of separators, one less than number of elements */;
+ assertEquals(expectedLength, sj.length());
+ }
+ assertEquals(EXPECTED, sj.toString());
+ }
+
+ public void testAddNone() {
+ StringJoiner sj = new StringJoiner(",", "[", "]");
+ assertEquals("[]", sj.toString());
+ assertEquals(2, sj.length()); // len("[]")
+ }
+
+ public void testAddNull() {
+ StringJoiner sj = new StringJoiner("|");
+ sj.add(null).add(null);
+ assertEquals("null|null", sj.toString());
+ }
+
+ public void testMerge() {
+ StringJoiner sj1 = new StringJoiner(" ", "[", "]").add("Hello").add("world");
+ StringJoiner sj2 = new StringJoiner("", "{", "}").add("Foo").add("Bar");
+ StringJoiner sj3 = new StringJoiner("!", "<", ">").add("a").add("b");
+ assertEquals("[Hello world FooBar a!b]", sj1.merge(sj2).merge(sj3).toString());
+ }
+
+ public void testMergeEmpty() {
+ StringJoiner sj1 = new StringJoiner(",").add("");
+ StringJoiner sj2 = new StringJoiner(".");
+ assertEquals("", sj1.merge(sj2).toString());
+ }
+
+ public void testMergeSelf() {
+ StringJoiner sj = new StringJoiner(" ", "|", "|").add("Hello").add("world");
+ assertEquals("|Hello world Hello world|", sj.merge(sj).toString());
+ }
+
+ public void testMergeNull() {
+ try {
+ new StringJoiner(" ").merge(null);
+ fail();
+ } catch (NullPointerException expected) {}
+ }
+
+ public void testSetEmptyValue() {
+ StringJoiner sj = new StringJoiner(",", "[", "]").setEmptyValue("EMPTY");
+ assertEquals("EMPTY", sj.toString());
+ }
+
+ public void testSetEmptyValuePopulated() {
+ StringJoiner sj = new StringJoiner(",", "[", "]").add("FOOBAR").setEmptyValue("");
+ assertEquals("[FOOBAR]", sj.toString());
+ }
+
+ public void testSetEmptyValuePopulated2() {
+ StringJoiner sj = new StringJoiner(",").add("").setEmptyValue("FOOBAR");
+ assertEquals("", sj.toString());
+ }
+
+ public void testSetEmptyValueEmpty() {
+ StringJoiner sj = new StringJoiner(",", "[", "]").setEmptyValue("");
+ assertEquals("", sj.toString());
+ }
+
+ public void testSetEmptyValueNull() {
+ try {
+ StringJoiner sj = new StringJoiner(",", "[", "]").setEmptyValue(null);
+ fail();
+ } catch (NullPointerException expected) {}
+ }
+}
diff --git a/ojluni/src/main/java/java/lang/System.java b/ojluni/src/main/java/java/lang/System.java
index f296bf8..bd00e50 100755
--- a/ojluni/src/main/java/java/lang/System.java
+++ b/ojluni/src/main/java/java/lang/System.java
@@ -245,39 +245,27 @@
private static native void setErr0(PrintStream err);
/**
- * Sets the System security.
+ * Throws {@code SecurityException} (except in case {@code sm == null}).
*
- * <p> If there is a security manager already installed, this method first
- * calls the security manager's <code>checkPermission</code> method
- * with a <code>RuntimePermission("setSecurityManager")</code>
- * permission to ensure it's ok to replace the existing
- * security manager.
- * This may result in throwing a <code>SecurityException</code>.
+ * <p>Security managers do <i>not</i> provide a secure environment for
+ * executing untrusted code and are unsupported on Android. Untrusted code
+ * cannot be safely isolated within a single VM on Android, so this method
+ * <i>always</i> throws a {@code SecurityException} when passed a non-null SecurityManager
*
- * <p> Otherwise, the argument is established as the current
- * security manager. If the argument is <code>null</code> and no
- * security manager has been established, then no action is taken and
- * the method simply returns.
- *
- * @param s the security manager.
- * @exception SecurityException if the security manager has already
- * been set and its <code>checkPermission</code> method
- * doesn't allow it to be replaced.
- * @see #getSecurityManager
- * @see SecurityManager#checkPermission
- * @see java.lang.RuntimePermission
+ * @param sm a security manager
+ * @throws SecurityException always, unless {@code sm == null}
*/
- public static void setSecurityManager(final SecurityManager s) {
- // No-op on android.
+ public static void setSecurityManager(SecurityManager sm) {
+ if (sm != null) {
+ throw new SecurityException();
+ }
}
+
/**
- * Gets the system security interface.
+ * Always returns {@code null} in Android
*
- * @return if a security manager has already been established for the
- * current application, then that security manager is returned;
- * otherwise, <code>null</code> is returned.
- * @see #setSecurityManager
+ * @return {@code null} in Android
*/
public static SecurityManager getSecurityManager() {
// No-op on android.
diff --git a/ojluni/src/main/java/java/util/StringJoiner.java b/ojluni/src/main/java/java/util/StringJoiner.java
new file mode 100644
index 0000000..b6ba84c
--- /dev/null
+++ b/ojluni/src/main/java/java/util/StringJoiner.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) 2013, 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;
+
+/**
+ * {@code StringJoiner} is used to construct a sequence of characters separated
+ * by a delimiter and optionally starting with a supplied prefix
+ * and ending with a supplied suffix.
+ * <p>
+ * Prior to adding something to the {@code StringJoiner}, its
+ * {@code sj.toString()} method will, by default, return {@code prefix + suffix}.
+ * However, if the {@code setEmptyValue} method is called, the {@code emptyValue}
+ * supplied will be returned instead. This can be used, for example, when
+ * creating a string using set notation to indicate an empty set, i.e.
+ * <code>"{}"</code>, where the {@code prefix} is <code>"{"</code>, the
+ * {@code suffix} is <code>"}"</code> and nothing has been added to the
+ * {@code StringJoiner}.
+ *
+ * @apiNote
+ * <p>The String {@code "[George:Sally:Fred]"} may be constructed as follows:
+ *
+ * <pre> {@code
+ * StringJoiner sj = new StringJoiner(":", "[", "]");
+ * sj.add("George").add("Sally").add("Fred");
+ * String desiredString = sj.toString();
+ * }</pre>
+ * <p>
+ * A {@code StringJoiner} may be employed to create formatted output from a
+ * {@link java.util.stream.Stream} using
+ * {@link java.util.stream.Collectors#joining(CharSequence)}. For example:
+ *
+ * <pre> {@code
+ * List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
+ * String commaSeparatedNumbers = numbers.stream()
+ * .map(i -> i.toString())
+ * .collect(Collectors.joining(", "));
+ * }</pre>
+ *
+ * @see java.util.stream.Collectors#joining(CharSequence)
+ * @see java.util.stream.Collectors#joining(CharSequence, CharSequence, CharSequence)
+ * @since 1.8
+*/
+public final class StringJoiner {
+ private final String prefix;
+ private final String delimiter;
+ private final String suffix;
+
+ /*
+ * StringBuilder value -- at any time, the characters constructed from the
+ * prefix, the added element separated by the delimiter, but without the
+ * suffix, so that we can more easily add elements without having to jigger
+ * the suffix each time.
+ */
+ private StringBuilder value;
+
+ /*
+ * By default, the string consisting of prefix+suffix, returned by
+ * toString(), or properties of value, when no elements have yet been added,
+ * i.e. when it is empty. This may be overridden by the user to be some
+ * other value including the empty String.
+ */
+ private String emptyValue;
+
+ /**
+ * Constructs a {@code StringJoiner} with no characters in it, with no
+ * {@code prefix} or {@code suffix}, and a copy of the supplied
+ * {@code delimiter}.
+ * If no characters are added to the {@code StringJoiner} and methods
+ * accessing the value of it are invoked, it will not return a
+ * {@code prefix} or {@code suffix} (or properties thereof) in the result,
+ * unless {@code setEmptyValue} has first been called.
+ *
+ * @param delimiter the sequence of characters to be used between each
+ * element added to the {@code StringJoiner} value
+ * @throws NullPointerException if {@code delimiter} is {@code null}
+ */
+ public StringJoiner(CharSequence delimiter) {
+ this(delimiter, "", "");
+ }
+
+ /**
+ * Constructs a {@code StringJoiner} with no characters in it using copies
+ * of the supplied {@code prefix}, {@code delimiter} and {@code suffix}.
+ * If no characters are added to the {@code StringJoiner} and methods
+ * accessing the string value of it are invoked, it will return the
+ * {@code prefix + suffix} (or properties thereof) in the result, unless
+ * {@code setEmptyValue} has first been called.
+ *
+ * @param delimiter the sequence of characters to be used between each
+ * element added to the {@code StringJoiner}
+ * @param prefix the sequence of characters to be used at the beginning
+ * @param suffix the sequence of characters to be used at the end
+ * @throws NullPointerException if {@code prefix}, {@code delimiter}, or
+ * {@code suffix} is {@code null}
+ */
+ public StringJoiner(CharSequence delimiter,
+ CharSequence prefix,
+ CharSequence suffix) {
+ Objects.requireNonNull(prefix, "The prefix must not be null");
+ Objects.requireNonNull(delimiter, "The delimiter must not be null");
+ Objects.requireNonNull(suffix, "The suffix must not be null");
+ // make defensive copies of arguments
+ this.prefix = prefix.toString();
+ this.delimiter = delimiter.toString();
+ this.suffix = suffix.toString();
+ this.emptyValue = this.prefix + this.suffix;
+ }
+
+ /**
+ * Sets the sequence of characters to be used when determining the string
+ * representation of this {@code StringJoiner} and no elements have been
+ * added yet, that is, when it is empty. A copy of the {@code emptyValue}
+ * parameter is made for this purpose. Note that once an add method has been
+ * called, the {@code StringJoiner} is no longer considered empty, even if
+ * the element(s) added correspond to the empty {@code String}.
+ *
+ * @param emptyValue the characters to return as the value of an empty
+ * {@code StringJoiner}
+ * @return this {@code StringJoiner} itself so the calls may be chained
+ * @throws NullPointerException when the {@code emptyValue} parameter is
+ * {@code null}
+ */
+ public StringJoiner setEmptyValue(CharSequence emptyValue) {
+ this.emptyValue = Objects.requireNonNull(emptyValue,
+ "The empty value must not be null").toString();
+ return this;
+ }
+
+ /**
+ * Returns the current value, consisting of the {@code prefix}, the values
+ * added so far separated by the {@code delimiter}, and the {@code suffix},
+ * unless no elements have been added in which case, the
+ * {@code prefix + suffix} or the {@code emptyValue} characters are returned
+ *
+ * @return the string representation of this {@code StringJoiner}
+ */
+ @Override
+ public String toString() {
+ if (value == null) {
+ return emptyValue;
+ } else {
+ if (suffix.equals("")) {
+ return value.toString();
+ } else {
+ int initialLength = value.length();
+ String result = value.append(suffix).toString();
+ // reset value to pre-append initialLength
+ value.setLength(initialLength);
+ return result;
+ }
+ }
+ }
+
+ /**
+ * Adds a copy of the given {@code CharSequence} value as the next
+ * element of the {@code StringJoiner} value. If {@code newElement} is
+ * {@code null}, then {@code "null"} is added.
+ *
+ * @param newElement The element to add
+ * @return a reference to this {@code StringJoiner}
+ */
+ public StringJoiner add(CharSequence newElement) {
+ prepareBuilder().append(newElement);
+ return this;
+ }
+
+ /**
+ * Adds the contents of the given {@code StringJoiner} without prefix and
+ * suffix as the next element if it is non-empty. If the given {@code
+ * StringJoiner} is empty, the call has no effect.
+ *
+ * <p>A {@code StringJoiner} is empty if {@link #add(CharSequence) add()}
+ * has never been called, and if {@code merge()} has never been called
+ * with a non-empty {@code StringJoiner} argument.
+ *
+ * <p>If the other {@code StringJoiner} is using a different delimiter,
+ * then elements from the other {@code StringJoiner} are concatenated with
+ * that delimiter and the result is appended to this {@code StringJoiner}
+ * as a single element.
+ *
+ * @param other The {@code StringJoiner} whose contents should be merged
+ * into this one
+ * @throws NullPointerException if the other {@code StringJoiner} is null
+ * @return This {@code StringJoiner}
+ */
+ public StringJoiner merge(StringJoiner other) {
+ Objects.requireNonNull(other);
+ if (other.value != null) {
+ final int length = other.value.length();
+ // lock the length so that we can seize the data to be appended
+ // before initiate copying to avoid interference, especially when
+ // merge 'this'
+ StringBuilder builder = prepareBuilder();
+ builder.append(other.value, other.prefix.length(), length);
+ }
+ return this;
+ }
+
+ private StringBuilder prepareBuilder() {
+ if (value != null) {
+ value.append(delimiter);
+ } else {
+ value = new StringBuilder().append(prefix);
+ }
+ return value;
+ }
+
+ /**
+ * Returns the length of the {@code String} representation
+ * of this {@code StringJoiner}. Note that if
+ * no add methods have been called, then the length of the {@code String}
+ * representation (either {@code prefix + suffix} or {@code emptyValue})
+ * will be returned. The value should be equivalent to
+ * {@code toString().length()}.
+ *
+ * @return the length of the current value of {@code StringJoiner}
+ */
+ public int length() {
+ // Remember that we never actually append the suffix unless we return
+ // the full (present) value or some sub-string or length of it, so that
+ // we can add on more if we need to.
+ return (value != null ? value.length() + suffix.length() :
+ emptyValue.length());
+ }
+}
diff --git a/openjdk_java_files.mk b/openjdk_java_files.mk
index 03a87bf..29bbb79 100644
--- a/openjdk_java_files.mk
+++ b/openjdk_java_files.mk
@@ -695,6 +695,7 @@
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/StringJoiner.java \
ojluni/src/main/java/java/util/Tripwire.java \
ojluni/src/main/java/java/util/DoubleSummaryStatistics.java \
ojluni/src/main/java/java/util/IntSummaryStatistics.java \
