From 113c48f5da32b26a4f820ccd0e43dae3eba7b73e Mon Sep 17 00:00:00 2001 From: Claes Redestad Date: Fri, 22 May 2020 11:20:57 +0200 Subject: [PATCH] 8215401: Add isEmpty default method to CharSequence Reviewed-by: jlaskey, rriggs, jjg, alanb, smarks, darcy --- .../share/classes/java/lang/CharSequence.java | 17 ++- .../share/classes/java/lang/String.java | 1 + .../classes/java/nio/X-Buffer.java.template | 12 ++ .../jdk/java/lang/CharSequence/Emptiness.java | 104 ++++++++++++++++++ 4 files changed, 133 insertions(+), 1 deletion(-) create mode 100644 test/jdk/java/lang/CharSequence/Emptiness.java diff --git a/src/java.base/share/classes/java/lang/CharSequence.java b/src/java.base/share/classes/java/lang/CharSequence.java index dc2cf4266586c..c21a2be79550c 100644 --- a/src/java.base/share/classes/java/lang/CharSequence.java +++ b/src/java.base/share/classes/java/lang/CharSequence.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 2020, 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 @@ -87,6 +87,21 @@ public interface CharSequence { */ char charAt(int index); + /** + * Returns {@code true} if this character sequence is empty. + * + * @implSpec + * The default implementation returns the result of calling {@code length() == 0}. + * + * @return {@code true} if {@link #length()} is {@code 0}, otherwise + * {@code false} + * + * @since 15 + */ + default boolean isEmpty() { + return this.length() == 0; + } + /** * Returns a {@code CharSequence} that is a subsequence of this sequence. * The subsequence starts with the {@code char} value at the specified index and diff --git a/src/java.base/share/classes/java/lang/String.java b/src/java.base/share/classes/java/lang/String.java index 6b0b48d8021ee..466e9d4ef62dd 100644 --- a/src/java.base/share/classes/java/lang/String.java +++ b/src/java.base/share/classes/java/lang/String.java @@ -684,6 +684,7 @@ public int length() { * * @since 1.6 */ + @Override public boolean isEmpty() { return value.length == 0; } diff --git a/src/java.base/share/classes/java/nio/X-Buffer.java.template b/src/java.base/share/classes/java/nio/X-Buffer.java.template index 4c550d1fb0c27..88dc63ce80863 100644 --- a/src/java.base/share/classes/java/nio/X-Buffer.java.template +++ b/src/java.base/share/classes/java/nio/X-Buffer.java.template @@ -1645,6 +1645,18 @@ public abstract class $Type$Buffer return remaining(); } + /** + * Returns {@code true} if this character buffer is empty. + * + * @return {@code true} if there are {@code 0} remaining characters, + * otherwise {@code false} + * + * @since 15 + */ + public final boolean isEmpty() { + return remaining() == 0; + } + /** * Reads the character at the given index relative to the current * position. diff --git a/test/jdk/java/lang/CharSequence/Emptiness.java b/test/jdk/java/lang/CharSequence/Emptiness.java new file mode 100644 index 0000000000000..a0d86384d7c04 --- /dev/null +++ b/test/jdk/java/lang/CharSequence/Emptiness.java @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2020, 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. + * + * 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. + */ + +import java.nio.ByteBuffer; +import java.nio.CharBuffer; + +import org.testng.Assert; +import org.testng.annotations.Test; + +/** + * @test + * @bug 8215401 + * @summary Test to verify the isEmpty method is behaviorally consistent + * with length + * @run testng Emptiness + */ +public class Emptiness { + + @Test + public void isEmpty() { + checkEmpty(new StringBuilder()); + checkEmpty(new StringBuffer()); + checkEmpty(""); + checkEmpty(new CharSequence() { + @Override public int length() { return 0; } + @Override public char charAt(int index) { return 'f'; } + @Override public CharSequence subSequence(int start, int end) { + throw new UnsupportedOperationException(); + } + }); + checkEmpty(CharBuffer.wrap(new char[0])); + checkEmpty(CharBuffer.wrap("")); + + // A CharBuffer being filled is empty when there's no room remaining + // - or there's nothing in the buffer after a flip + checkEmpty(ByteBuffer.allocate(0).asCharBuffer()); + checkEmpty(ByteBuffer.allocate(2).asCharBuffer().append('f')); + checkEmpty(ByteBuffer.allocate(2).asCharBuffer().flip()); + + checkEmpty(ByteBuffer.allocateDirect(0).asCharBuffer()); + checkEmpty(ByteBuffer.allocateDirect(2).asCharBuffer().append('f')); + checkEmpty(ByteBuffer.allocateDirect(2).asCharBuffer().flip()); + } + + @Test + public void isNotEmpty() { + checkNotEmpty(new StringBuilder().append("foo")); + checkNotEmpty(new StringBuffer().append("bar")); + checkNotEmpty("baz"); + checkNotEmpty(new CharSequence() { + @Override public int length() { return 1; } + @Override public char charAt(int index) { return 'f'; } + @Override public CharSequence subSequence(int start, int end) { + throw new UnsupportedOperationException(); + } + }); + checkNotEmpty(CharBuffer.wrap(new char[] { 'f' })); + checkNotEmpty(CharBuffer.wrap("foo")); + + // A CharBuffer being filled is non-empty when there's room remaining + // - or when there's something in the buffer after a flip + checkNotEmpty(ByteBuffer.allocate(2).asCharBuffer()); + checkNotEmpty(ByteBuffer.allocate(4).asCharBuffer().append('f')); + checkNotEmpty(ByteBuffer.allocate(2).asCharBuffer().append('f').flip()); + + checkNotEmpty(ByteBuffer.allocateDirect(2).asCharBuffer()); + checkNotEmpty(ByteBuffer.allocateDirect(4).asCharBuffer().append('f')); + checkNotEmpty(ByteBuffer.allocateDirect(2).asCharBuffer().append('f').flip()); + } + + public void checkEmpty(CharSequence cs) { + Assert.assertTrue(cs.isEmpty()); + Assert.assertTrue(consistentWithLength(cs)); + } + + public void checkNotEmpty(CharSequence cs) { + Assert.assertTrue(!cs.isEmpty()); + Assert.assertTrue(consistentWithLength(cs)); + } + + public boolean consistentWithLength(CharSequence cs) { + return cs.isEmpty() == (cs.length() == 0); + } +}