From 9a1c3c8199d3687009610b3a7798cbba0a1ae2d0 Mon Sep 17 00:00:00 2001
From: Suyash Jain <96700361+gitkaarma@users.noreply.github.com>
Date: Thu, 30 Jan 2025 12:42:15 +0530
Subject: [PATCH] feat: Add Java 11 String methods to JPF String class (#512)

* feat: add java 11 string methods to JPF string class

* feat: added lines method to string class

* fix: test case fix

* fix: remove stream import

---------

Co-authored-by: sjain39 <suyash_jain@intuit.com>
---
 .../modules/java.base/java/lang/String.java   | 55 +++++++++++++++++++
 .../nasa/jpf/test/java/lang/StringTest.java   | 50 +++++++++++++++++
 2 files changed, 105 insertions(+)

diff --git a/src/classes/modules/java.base/java/lang/String.java b/src/classes/modules/java.base/java/lang/String.java
index 2134d830..19c655b0 100644
--- a/src/classes/modules/java.base/java/lang/String.java
+++ b/src/classes/modules/java.base/java/lang/String.java
@@ -501,5 +501,60 @@ static void checkIndex(int index, int length) {
     }
   }
 
+	public boolean isBlank() {
+		return isEmpty() || strip().isEmpty();
+	}
+
+	public String strip() {
+		return stripLeading().stripTrailing();
+	}
+
+	public String stripLeading() {
+		int start = 0;
+		while (start < value.length && Character.isWhitespace(charAt(start))) {
+			start++;
+		}
+		return substring(start);
+	}
+
+	public String stripTrailing() {
+		int end = value.length;
+		while (end > 0 && Character.isWhitespace(charAt(end - 1))) {
+			end--;
+		}
+		return substring(0, end);
+	}
+
+	public String repeat(int count) {
+		if (count < 0) {
+			throw new IllegalArgumentException("count is negative: " + count);
+		}
+		if (count == 1 || isEmpty()) {
+			return this;
+		}
+		final int len = value.length;
+		if (len == 0 || count == 0) {
+			return "";
+		}
+		if (len == 1) {
+			final byte[] single = new byte[count];
+			Arrays.fill(single, value[0]);
+			return new String(single, coder);
+		}
+		final int limit = Integer.MAX_VALUE / count;
+		if (len > limit) {
+			throw new OutOfMemoryError("Repeating " + len + " bytes String " + count +
+					" times will produce a String exceeding maximum size.");
+		}
+		final int newLength = len * count;
+		final byte[] multiple = new byte[newLength];
+		System.arraycopy(value, 0, multiple, 0, len);
+		int copied = len;
+		for (; copied < newLength - copied; copied <<= 1) {
+			System.arraycopy(multiple, 0, multiple, copied, copied);
+		}
+		System.arraycopy(multiple, 0, multiple, copied, newLength - copied);
+		return new String(multiple, coder);
+	}
 }
 
diff --git a/src/tests/gov/nasa/jpf/test/java/lang/StringTest.java b/src/tests/gov/nasa/jpf/test/java/lang/StringTest.java
index cb7fdb16..03911497 100644
--- a/src/tests/gov/nasa/jpf/test/java/lang/StringTest.java
+++ b/src/tests/gov/nasa/jpf/test/java/lang/StringTest.java
@@ -23,8 +23,10 @@
 import java.io.UnsupportedEncodingException;
 import java.nio.charset.Charset;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Locale;
 import java.util.TreeSet;
+import java.util.stream.Collectors;
 
 import org.junit.Test;
 
@@ -310,4 +312,52 @@ public void testConcat() {
 			assert out.equals("Hello, World!");
 		}
 	}
+
+	@Test
+	public void testIsBlank() {
+		if (verifyNoPropertyViolation()) {
+			assertTrue("".isBlank());
+			assertTrue("   ".isBlank());
+			assertTrue("\t\n\r".isBlank());
+			assertFalse("  a  ".isBlank());
+			assertFalse("abc".isBlank());
+		}
+	}
+
+	@Test
+	public void testStrip() {
+		if (verifyNoPropertyViolation()) {
+			assertEquals("abc", "  abc  ".strip());
+			assertEquals("abc", "abc".strip());
+			assertEquals("", "  ".strip());
+		}
+	}
+
+	@Test
+	public void testStripLeading() {
+		if (verifyNoPropertyViolation()) {
+			assertEquals("abc  ", "  abc  ".stripLeading());
+			assertEquals("abc", "abc".stripLeading());
+			assertEquals("", "  ".stripLeading());
+		}
+	}
+
+	@Test
+	public void testStripTrailing() {
+		if (verifyNoPropertyViolation()) {
+			assertEquals("  abc", "  abc  ".stripTrailing());
+			assertEquals("abc", "abc".stripTrailing());
+			assertEquals("", "  ".stripTrailing());
+		}
+	}
+
+	@Test
+	public void testRepeat() {
+		if (verifyNoPropertyViolation()) {
+			assertEquals("", "abc".repeat(0));
+			assertEquals("abc", "abc".repeat(1));
+			assertEquals("abcabc", "abc".repeat(2));
+			assertEquals("  ", " ".repeat(2));
+		}
+	}
 }