findRecursionMonitor(Object obj) {
+ return Optional.of(OBJECT_REGISTRY)
+ .map(ThreadLocal::get)
+ .map(map -> map.get(obj));
+ }
+
+ /**
+ * Checks if the thread-local registry is empty.
+ * @return True if no objects are currently being processed; false otherwise.
+ */
+ static boolean isEmpty() {
+ return OBJECT_REGISTRY.get().isEmpty();
+ }
+}
diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/util/tostring/SBLengthLimit.java b/modules/commons/src/main/java/org/apache/ignite/internal/util/tostring/SBLengthLimit.java
index 58a070eef3ac3..151166c15de58 100644
--- a/modules/commons/src/main/java/org/apache/ignite/internal/util/tostring/SBLengthLimit.java
+++ b/modules/commons/src/main/java/org/apache/ignite/internal/util/tostring/SBLengthLimit.java
@@ -35,50 +35,44 @@ class SBLengthLimit {
/** Length of head part of message. */
private static final int HEAD_LEN = MAX_TO_STR_LEN - TAIL_LEN;
- /** */
- private int len;
-
- /**
- * @return Current length.
- */
- int length() {
- return len;
- }
-
- /**
- *
- */
- void reset() {
- len = 0;
- }
-
/**
* @param sb String builder.
* @param writtenLen Written length.
*/
void onWrite(SBLimitedLength sb, int writtenLen) {
- len += writtenLen;
-
if (overflowed(sb) && (sb.getTail() == null || sb.getTail().length() == 0)) {
- CircularStringBuilder tail = getTail();
-
- int newSbLen = Math.min(sb.length(), HEAD_LEN + 1);
+ CircularStringBuilder tail = createTail();
+ int newSbLen = Math.min(sb.length(), getHeadLengthLimit());
tail.append(sb.impl().substring(newSbLen));
-
sb.setTail(tail);
- sb.setLength(newSbLen);
+ sb.impl().setLength(newSbLen);
}
}
- /** */
- CircularStringBuilder getTail() {
- return new CircularStringBuilder(TAIL_LEN);
+ /** Creates empty tail
+ * @return empty tail */
+ CircularStringBuilder createTail() {
+ return new CircularStringBuilder(getTailLengthLimit());
}
/**
- * @return {@code True} if reached limit.
+ * @return {@code True} if this string builder exceeds limit, false otherwise
*/
boolean overflowed(SBLimitedLength sb) {
- return sb.impl().length() > HEAD_LEN;
+ return sb.length() >= getHeadLengthLimit();
+ }
+
+ /**
+ * Returns max available head length
+ * @return head limit */
+ int getHeadLengthLimit() {
+ return HEAD_LEN;
+ }
+
+ /**
+ *
+ */
+ int getTailLengthLimit() {
+ return TAIL_LEN;
}
}
diff --git a/modules/commons/src/main/java/org/apache/ignite/internal/util/tostring/SBLimitedLength.java b/modules/commons/src/main/java/org/apache/ignite/internal/util/tostring/SBLimitedLength.java
index d478e3cbcc391..6f37fa594630b 100644
--- a/modules/commons/src/main/java/org/apache/ignite/internal/util/tostring/SBLimitedLength.java
+++ b/modules/commons/src/main/java/org/apache/ignite/internal/util/tostring/SBLimitedLength.java
@@ -17,11 +17,32 @@
package org.apache.ignite.internal.util.tostring;
-import java.util.Arrays;
+import org.apache.ignite.internal.util.CommonUtils;
import org.apache.ignite.internal.util.GridStringBuilder;
/**
+ * A specialized string builder that enforces a maximum length limit
+ * by splitting the content into two parts:
+ *
+ * - Head: The main buffer managed by the parent {@link GridStringBuilder}.
+ * Its size is constrained by a provided {@link SBLengthLimit}.
+ * - Tail: An auxiliary {@link CircularStringBuilder}
+ * that stores any overflow data once the head reaches its capacity.
+ *
*
+ * This class overrides all mutating methods to redirect new data to the tail
+ * when the length limit is exceeded, effectively making it an "append-only" structure
+ * for the head buffer once the limit is reached.
+ *
+ *
Important Behavior:
+ * All operations that can reduce or delete characters from the head buffer
+ * will throw an {@link UnsupportedOperationException}.
+ * This design decision ensures the integrity of the length-limited head
+ * and simplifies internal logic.
+ *
+ *
The {@code toString()} method provides
+ * a unified representation of both head and tail contents,
+ * optionally indicating skipped characters between them.
*/
public class SBLimitedLength extends GridStringBuilder {
/** */
@@ -45,21 +66,6 @@ public class SBLimitedLength extends GridStringBuilder {
*/
void initLimit(SBLengthLimit lenLimit) {
this.lenLimit = lenLimit;
-
- if (tail != null)
- tail.reset();
- }
-
- /**
- * Resets buffer.
- */
- public void reset() {
- super.setLength(0);
-
- lenLimit.reset();
-
- if (tail != null)
- tail.reset();
}
/**
@@ -159,31 +165,15 @@ private GridStringBuilder onWrite(int lenBeforeWrite) {
}
/** {@inheritDoc} */
- @Override public GridStringBuilder a(char[] str) {
- if (lenLimit.overflowed(this)) {
- tail.append(str);
- return this;
- }
-
- int curLen = length();
-
- super.a(str);
-
- return onWrite(curLen);
+ @Override public GridStringBuilder a(char[] arr) {
+ String str = new String(arr);
+ return a(str);
}
/** {@inheritDoc} */
- @Override public GridStringBuilder a(char[] str, int offset, int len) {
- if (lenLimit.overflowed(this)) {
- tail.append(Arrays.copyOfRange(str, offset, len));
- return this;
- }
-
- int curLen = length();
-
- super.a(str, offset, len);
-
- return onWrite(curLen);
+ @Override public GridStringBuilder a(char[] arr, int offset, int len) {
+ String str = new String(arr, offset, len);
+ return a(str);
}
/** {@inheritDoc} */
@@ -270,6 +260,121 @@ private GridStringBuilder onWrite(int lenBeforeWrite) {
return onWrite(curLen);
}
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder i(int offset, String str) {
+ int headLengthLimit = lenLimit.getHeadLengthLimit();
+ if (offset < headLengthLimit) {
+ super.i(offset, str);
+ if (lenLimit.overflowed(this)) {
+ String tailCandidate = impl().substring(headLengthLimit);
+ if (tail == null)
+ tail = lenLimit.createTail();
+ tail.insert(0, tailCandidate);
+ impl().setLength(headLengthLimit);
+ }
+ return this;
+ }
+ tail.insert(offset - headLengthLimit, str);
+ return this;
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder i(int idx, char[] str, int off, int len) {
+ StringBuilder strBuilder = new StringBuilder();
+ for (int i = 0; i < len; i++)
+ strBuilder.append(str[i + off]);
+ return i(idx, strBuilder.toString());
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder i(int off, Object obj) {
+ return i(off, String.valueOf(obj));
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder i(int off, char[] str) {
+ return i(off, new String(str));
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder i(int dstOff, CharSequence s) {
+ StringBuilder strBuilder = new StringBuilder();
+ for (int i = 0; i < s.length(); i++)
+ strBuilder.append(s.charAt(i));
+ return i(dstOff, strBuilder.toString());
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder i(int dstOff, CharSequence s, int start, int end) {
+ StringBuilder strBuilder = new StringBuilder();
+ for (int i = start; i < end; i++)
+ strBuilder.append(s.charAt(i));
+ return i(dstOff, strBuilder.toString());
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder i(int off, boolean b) {
+ return super.i(off, String.valueOf(b));
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder i(int off, char c) {
+ return super.i(off, String.valueOf(c));
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder i(int off, int i) {
+ return super.i(off, String.valueOf(i));
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder i(int off, long l) {
+ return super.i(off, String.valueOf(l));
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder i(int off, float f) {
+ return super.i(off, String.valueOf(f));
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder i(int off, double d) {
+ return super.i(off, String.valueOf(d));
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder d(int start, int end) {
+ throw new UnsupportedOperationException("Not supported by this implementation");
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder d(int idx) {
+ throw new UnsupportedOperationException("Not supported by this implementation");
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder r(int start, int end, String str) {
+ throw new UnsupportedOperationException("Not supported by this implementation");
+ }
+
+ /** {@inheritDoc} */
+ @Override public GridStringBuilder nl() {
+ return a(CommonUtils.nl());
+ }
+
+ /** {@inheritDoc} */
+ @Override public int length() {
+ int length = super.length();
+ if (tail != null)
+ length += tail.getSkipped() + tail.length();
+ return length;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void setLength(int len) {
+ throw new UnsupportedOperationException("setLength is not supported by this imlementation");
+ }
+
/** {@inheritDoc} */
@Override public GridStringBuilder appendCodePoint(int codePoint) {
if (lenLimit.overflowed(this)) {
@@ -304,11 +409,4 @@ private GridStringBuilder onWrite(int lenBeforeWrite) {
return res.toString();
}
}
-
- /**
- * @return {@code True} - if buffer limit is reached.
- */
- public boolean isOverflowed() {
- return lenLimit.overflowed(this);
- }
}
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/CircularStringBuilderSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/CircularStringBuilderSelfTest.java
index f9bf453663793..01317876c493d 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/CircularStringBuilderSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/CircularStringBuilderSelfTest.java
@@ -55,6 +55,56 @@ public void testCSBOverflow() throws Exception {
testSB(8, "1234", 2, "12341234");
}
+ /** Assertions to ensure {@link CircularStringBuilder#insert(int, String)} method works */
+ @Test
+ public void testCSBInsert() {
+ testSBInsert(5, "123456789", 4, "new", "56789");
+ testSBInsert(5, "123456789", 5, "new", "w6789");
+ testSBInsert(5, "123456789", 6, "new", "ew789");
+ testSBInsert(5, "123456789", 7, "new", "new89");
+ testSBInsert(5, "123456789", 8, "new", "8new9");
+ testSBInsert(5, "123456789", 9, "new", "89new");
+ testSBInsert(5, "1", 0, "new", "new1");
+ testSBInsert(5, "12", 0, "new", "new12");
+ testSBInsert(5, "123", 0, "new", "ew123");
+ testSBInsert(5, "1234", 0, "new", "w1234");
+ testSBInsert(2, "1", 0, "new", "w1");
+ testSBInsert(2, "12", 0, "new", "12");
+ testSBInsert(3, "12", 0, "new", "w12");
+ testSBInsert(3, "12", 1, "new", "ew2");
+ }
+
+ /** Assertions to ensure {@link CircularStringBuilder#substring(int, int)} method works */
+ @Test
+ public void testSubstring() {
+ CircularStringBuilder circularStrBuilder = new CircularStringBuilder(5);
+ circularStrBuilder.append("abc");
+ assertEquals("abc", circularStrBuilder.substring(0, 3));
+ assertEquals("ab", circularStrBuilder.substring(0, 2));
+ assertEquals("bc", circularStrBuilder.substring(1, 3));
+ circularStrBuilder.append("de");
+ assertEquals("abc", circularStrBuilder.substring(0, 3));
+ assertEquals("ab", circularStrBuilder.substring(0, 2));
+ assertEquals("bc", circularStrBuilder.substring(1, 3));
+ assertEquals("abcde", circularStrBuilder.substring(0, 5));
+ assertEquals("de", circularStrBuilder.substring(3, 5));
+ assertEquals("abc", circularStrBuilder.substring(0, 3));
+ circularStrBuilder.append("fg");
+ assertEquals("cdefg", circularStrBuilder.substring(2, 7));
+ assertEquals("cdef", circularStrBuilder.substring(2, 6));
+ assertEquals("defg", circularStrBuilder.substring(3, 7));
+ assertEquals("cdefg", circularStrBuilder.substring(0, 7));
+ circularStrBuilder.append("hi");
+ assertEquals("efg", circularStrBuilder.substring(0, 7));
+ assertEquals("efghi", circularStrBuilder.substring(0, 9));
+ circularStrBuilder.append("j");
+ assertEquals("fghi", circularStrBuilder.substring(0, 9));
+ assertEquals("fghij", circularStrBuilder.substring(0, 10));
+ assertEquals("ghij", circularStrBuilder.substring(6, 10));
+ assertEquals("", circularStrBuilder.substring(0, 5));
+ assertEquals("f", circularStrBuilder.substring(0, 6));
+ }
+
/**
* @param capacity Capacity.
* @param pattern Pattern to add.
@@ -69,4 +119,24 @@ private void testSB(int capacity, String pattern, int num, String expected) {
assertEquals(expected, csb.toString());
}
+
+ /**
+ * Test ring buffer method {@link CircularStringBuilder#insert(int, String)}
+ * @param capacity ring buffer capacity
+ * @param firstVal value to append to buffer before test
+ * @param offset insert offset argument
+ * @param insertSubstring insert substring argument
+ * @param expectedResult expected ring buffer state
+ * (to assert it equals to {@link CircularStringBuilder#toString()})
+ */
+ private void testSBInsert(int capacity,
+ String firstVal,
+ int offset,
+ String insertSubstring,
+ String expectedResult) {
+ CircularStringBuilder csb = new CircularStringBuilder(capacity);
+ csb.append(firstVal);
+ csb.insert(offset, insertSubstring);
+ assertEquals(expectedResult, csb.toString());
+ }
}
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/GridToStringBuilderSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/GridToStringBuilderSelfTest.java
index 4b2987c1431b5..a8a8b0d641303 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/GridToStringBuilderSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/GridToStringBuilderSelfTest.java
@@ -204,6 +204,97 @@ public void testToStringCheckObjectRecursionPrevention() throws Exception {
fut4.get(3_000);
}
+ /** */
+ @Test
+ public void testSetLength() {
+ SBLimitedLength sbLimitedLength = new SBLimitedLength(256);
+ SBLengthLimit sbLengthLimit = new SBLengthLimit();
+ sbLimitedLength.initLimit(sbLengthLimit);
+
+ }
+
+ /** */
+ @Test
+ public void testObjectRecursionPrevention() {
+ RecursivePayload recursivePayload1 = new RecursivePayload(8_000, null);
+ RecursivePayload recursivePayload2 = new RecursivePayload(4_000, recursivePayload1);
+ recursivePayload1.setChild(recursivePayload2);
+ String result;
+ result = recursivePayload1.toString();
+ info(result);
+ String identity = identity(recursivePayload1);
+ assertTrue(result.matches("^.*" + identity + ".*" + identity + ".*$"));
+ // it's in the middle
+ RecursivePayload recursivePayload0;
+ recursivePayload0 = new RecursivePayload(8, recursivePayload1);
+ result = recursivePayload0.toString();
+ info(result);
+ assertTrue(result.matches("^.*" + identity + ".*" + identity + ".*$"));
+ // it's in the head
+ recursivePayload0 = new RecursivePayload(8_000 - 60, recursivePayload1);
+ result = recursivePayload0.toString();
+ info(result);
+ assertTrue(result.matches("^.*" + identity + ".*" + identity + ".*$"));
+ // it's in the tail
+ recursivePayload1 = new RecursivePayload('1', 1, null);
+ identity = identity(recursivePayload1);
+ recursivePayload2 = new RecursivePayload('2', 1, recursivePayload1);
+ recursivePayload1.setChild(recursivePayload2);
+ recursivePayload0 = new RecursivePayload(8_001, recursivePayload1);
+ result = recursivePayload0.toString();
+ info(result);
+ assertTrue(result.matches("^.*" + identity + ".*" + identity + ".*$"));
+ }
+
+ /** */
+ private static class RecursivePayload {
+ /** */
+ private final String payload;
+
+ /** */
+ private RecursivePayload child;
+
+ /**
+ * Constructor
+ * @param payloadLength Payload length.
+ * @param child Child (nullable)
+ */
+ private RecursivePayload(int payloadLength, RecursivePayload child) {
+ this('a', payloadLength, child);
+ }
+
+ /**
+ * Constructor
+ * @param payloadChar PayloadChar
+ * @param payloadLength Payload length.
+ * @param child Child (nullable)
+ */
+ private RecursivePayload(char payloadChar, int payloadLength, RecursivePayload child) {
+ payload = String.valueOf(payloadChar).repeat(payloadLength);
+ this.child = child;
+ }
+
+ /** */
+ public String getPayload() {
+ return payload;
+ }
+
+ /** */
+ public RecursivePayload getChild() {
+ return child;
+ }
+
+ /** */
+ public void setChild(RecursivePayload child) {
+ this.child = child;
+ }
+
+ /** {@inheritDoc} */
+ @Override public String toString() {
+ return S.toString(RecursivePayload.class, this);
+ }
+ }
+
/**
* Test class.
*/
@@ -552,14 +643,13 @@ public void testHierarchy() {
checkHierarchy("Wrapper [p=Child [b=0, pb=Parent[] [null], super=Parent [a=0, pa=Parent[] [null]]]]", w);
p.pa[0] = p;
-
- checkHierarchy("Wrapper [p=Child" + hash +
- " [b=0, pb=Parent[] [null], super=Parent [a=0, pa=Parent[] [Child" + hash + "]]]]", w);
+ checkHierarchy("Wrapper [p=Child [b=0, pb=Parent[] [null], super=Parent" + hash +
+ " [a=0, pa=Parent[] [Child" + hash + "]]]]", w);
((Child)p).pb[0] = p;
checkHierarchy("Wrapper [p=Child" + hash + " [b=0, pb=Parent[] [Child" + hash
- + "], super=Parent [a=0, pa=Parent[] [Child" + hash + "]]]]", w);
+ + "], super=Parent" + hash + " [a=0, pa=Parent[] [Child" + hash + "]]]]", w);
}
/**
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/SBLimitedLengthSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/SBLimitedLengthSelfTest.java
new file mode 100644
index 0000000000000..e07d1e9caa1eb
--- /dev/null
+++ b/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/SBLimitedLengthSelfTest.java
@@ -0,0 +1,160 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.ignite.internal.util.tostring;
+
+import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest;
+import org.apache.ignite.testframework.junits.common.GridCommonTest;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Test suite to ensure SBLimitedLength works by design
+ */
+@GridCommonTest(group = "Utils")
+public class SBLimitedLengthSelfTest extends GridCommonAbstractTest {
+ /** Ensure all append operations are working fine */
+ @Test
+ public void testAppend() {
+ SBLimitedLength strBuilder = getStrBuilder(5, 50);
+ strBuilder.a(1);
+ Assert.assertEquals("1", strBuilder.toString());
+ strBuilder.a(2L);
+ Assert.assertEquals("12", strBuilder.toString());
+ strBuilder.a(3f);
+ Assert.assertEquals("123.0", strBuilder.toString());
+ strBuilder.a(4d);
+ Assert.assertEquals("123.04.0", strBuilder.toString());
+ strBuilder.a('5');
+ Assert.assertEquals("123.04.05", strBuilder.toString());
+ strBuilder.a(true);
+ Assert.assertEquals("123.04.05true", strBuilder.toString());
+ Object obj = "6";
+ strBuilder.a(obj);
+ Assert.assertEquals("123.04.05true6", strBuilder.toString());
+ strBuilder.a("7");
+ Assert.assertEquals("123.04.05true67", strBuilder.toString());
+ strBuilder.a(new StringBuilder().append("8"));
+ Assert.assertEquals("123.04.05true678", strBuilder.toString());
+ CharSequence charSeq = "9";
+ strBuilder.a(charSeq);
+ Assert.assertEquals("123.04.05true6789", strBuilder.toString());
+ strBuilder.a(charSeq, 0, 1);
+ Assert.assertEquals("123.04.05true67899", strBuilder.toString());
+ strBuilder.a(new char[]{'a'});
+ Assert.assertEquals("123.04.05true67899a", strBuilder.toString());
+ strBuilder.a(new char[]{'b', 'c', 'd'}, 0, 2);
+ Assert.assertEquals("123.04.05true67899abc", strBuilder.toString());
+ }
+
+ /** Ensure all insert operations are working fine */
+ @Test
+ public void testInsert() {
+ SBLimitedLength strBuilder = getStrBuilder(5, 50);
+ strBuilder.i(0, 1);
+ Assert.assertEquals("1", strBuilder.toString());
+ strBuilder.i(0, 2L);
+ Assert.assertEquals("21", strBuilder.toString());
+ strBuilder.i(0, 3f);
+ Assert.assertEquals("3.021", strBuilder.toString());
+ strBuilder.i(0, 4d);
+ Assert.assertEquals("4.03.021", strBuilder.toString());
+ strBuilder.i(0, true);
+ Assert.assertEquals("true4.03.021", strBuilder.toString());
+ strBuilder.i(0, '5');
+ Assert.assertEquals("5true4.03.021", strBuilder.toString());
+ strBuilder.i(1, "6");
+ Assert.assertEquals("56true4.03.021", strBuilder.toString());
+ strBuilder.i(2, new char[] {'a', 'b', 'c', 'd'});
+ Assert.assertEquals("56abcdtrue4.03.021", strBuilder.toString());
+ strBuilder.i(5, new char[] {'e', 'f', 'g', 'i'}, 0, 3);
+ Assert.assertEquals("56abcefgdtrue4.03.021", strBuilder.toString());
+ Object obj = "h";
+ strBuilder.i(6, obj);
+ Assert.assertEquals("56abcehfgdtrue4.03.021", strBuilder.toString());
+ CharSequence charSeq = "ijk";
+ strBuilder.i(7, charSeq);
+ Assert.assertEquals("56abcehijkfgdtrue4.03.021", strBuilder.toString());
+ strBuilder.i(8, charSeq, 0, 2);
+ Assert.assertEquals("56abcehiijjkfgdtrue4.03.021", strBuilder.toString());
+ }
+
+ /** Ensure toString works as expected */
+ @Test
+ public void testToString() {
+ SBLimitedLength strBuilder = getStrBuilder(2, 2);
+ strBuilder.a("ab");
+ Assert.assertEquals("ab", strBuilder.toString());
+ strBuilder.a("cd");
+ Assert.assertEquals("abcd", strBuilder.toString());
+ strBuilder.a("ef");
+ Assert.assertEquals("ab... and 4 skipped ...ef", strBuilder.toString());
+ }
+
+ /** Ensure all operations that could possibly reduce length are prohibited */
+ @Test
+ public void testLengthReduceOperationsAreProhibited() {
+ SBLimitedLength strBuilder = getStrBuilder(2, 2);
+ assertThrows(UnsupportedOperationException.class, () -> strBuilder.d(0));
+ assertThrows(UnsupportedOperationException.class, () -> strBuilder.d(0, 0));
+ assertThrows(UnsupportedOperationException.class, () -> strBuilder.r(0, 0, "asd"));
+ assertThrows(UnsupportedOperationException.class, () -> strBuilder.setLength(0));
+ }
+
+ /**
+ * Assert {@link Runnable#run()} will throw specified exception
+ * @param expectedExceptionClass Expected exception class.
+ * @param runnable Runnable.
+ */
+ private void assertThrows(Class expectedExceptionClass, Runnable runnable) {
+ boolean eIsSpotted = false;
+ try {
+ runnable.run();
+ }
+ catch (Throwable throwable) {
+ if (expectedExceptionClass.isAssignableFrom(throwable.getClass()))
+ eIsSpotted = true;
+ }
+ finally {
+ Assert.assertTrue(eIsSpotted);
+ }
+ }
+
+ /**
+ * Get {@link SBLimitedLength} instance with specific head and tail length
+ * to simplify test cases
+ * @param headLength Head length.
+ * @param tailLength Tail length.
+ */
+ private SBLimitedLength getStrBuilder(int headLength, int tailLength) {
+ SBLimitedLength sbLimitedLength = new SBLimitedLength(0);
+ sbLimitedLength.initLimit(new SBLengthLimit() {
+
+ @Override int getHeadLengthLimit() {
+ return headLength;
+ }
+
+ @Override int getTailLengthLimit() {
+ return tailLength;
+ }
+ });
+ return sbLimitedLength;
+ }
+}
+
+
+
diff --git a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteUtilSelfTestSuite.java b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteUtilSelfTestSuite.java
index c06cbfe8fd4c8..5b5d98fc87b1c 100644
--- a/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteUtilSelfTestSuite.java
+++ b/modules/core/src/test/java/org/apache/ignite/testsuites/IgniteUtilSelfTestSuite.java
@@ -50,6 +50,7 @@
import org.apache.ignite.internal.util.tostring.GridToStringBuilderSelfTest;
import org.apache.ignite.internal.util.tostring.IncludeSensitiveAtomicTest;
import org.apache.ignite.internal.util.tostring.IncludeSensitiveTransactionalTest;
+import org.apache.ignite.internal.util.tostring.SBLimitedLengthSelfTest;
import org.apache.ignite.internal.util.tostring.TransactionSensitiveDataTest;
import org.apache.ignite.lang.GridByteArrayListSelfTest;
import org.apache.ignite.spi.discovery.ClusterMetricsSelfTest;
@@ -91,6 +92,7 @@
GridStringBuilderFactorySelfTest.class,
GridToStringBuilderSelfTest.class,
CircularStringBuilderSelfTest.class,
+ SBLimitedLengthSelfTest.class,
GridByteArrayListSelfTest.class,
GridMBeanSelfTest.class,
GridMBeanDisableSelfTest.class,