View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      https://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.commons.lang3.builder;
19  
20  import static org.junit.jupiter.api.Assertions.assertEquals;
21  import static org.junit.jupiter.api.Assertions.assertNotNull;
22  import static org.junit.jupiter.api.Assertions.assertNull;
23  import static org.junit.jupiter.api.Assertions.assertThrows;
24  import static org.junit.jupiter.api.Assertions.assertTrue;
25  
26  import java.lang.ref.Reference;
27  import java.util.Map;
28  import java.util.Set;
29  import java.util.function.BiConsumer;
30  import java.util.function.Consumer;
31  import java.util.stream.Stream;
32  
33  import org.apache.commons.lang3.AbstractLangTest;
34  import org.apache.commons.lang3.ObjectUtils;
35  import org.apache.commons.lang3.StringUtils;
36  import org.junit.jupiter.api.AfterEach;
37  import org.junit.jupiter.api.BeforeEach;
38  import org.junit.jupiter.api.Test;
39  import org.junit.jupiter.params.ParameterizedTest;
40  import org.junit.jupiter.params.provider.MethodSource;
41  
42  /**
43   * Tests visited-object ownership across builder traversals.
44   */
45  class ToStringBuilderTraversalTest extends AbstractLangTest {
46  
47      private static final class FailingStyle extends RecursiveToStringStyle {
48  
49          private static final long serialVersionUID = 1L;
50          private final Object failure;
51  
52          FailingStyle(final Object failure) {
53              this.failure = failure;
54          }
55  
56          @Override
57          public void appendDetail(final StringBuffer buffer, final String fieldName, final Object value) {
58              if (value == failure) {
59                  throw new IllegalStateException("Cannot render field");
60              }
61              super.appendDetail(buffer, fieldName, value);
62          }
63      }
64  
65      private static final class IdentityOnly {
66  
67          @Override
68          public boolean equals(final Object other) {
69              throw new AssertionError("Traversal must not call equals()");
70          }
71  
72          @Override
73          public int hashCode() {
74              throw new AssertionError("Traversal must not call hashCode()");
75          }
76      }
77  
78      static Stream<BiConsumer<ToStringBuilder, Object[]>> appenders() {
79          // @formatter:off
80          return Stream.of(
81                  (builder, array) -> builder.append((Object) array),
82                  (builder, array) -> builder.append(array),
83                  (builder, array) -> builder.append("value", (Object) array),
84                  (builder, array) -> builder.append("value", array),
85                  (builder, array) -> builder.append("value", (Object) array, true),
86                  (builder, array) -> builder.append("value", array, true));
87          // @formatter:on
88      }
89  
90      private static void assertNoVisitedObjects() {
91          assertNull(ToStringStyle.getActiveTraversal(), "The traversal must have ended");
92          final Map<?, ?> direct = ToStringStyle.getDirectTraversals().get();
93          assertTrue(direct == null || direct.isEmpty(), "Completed direct style output must release its traversal");
94      }
95  
96      private static Set<?> builderVisited(final ToStringBuilder builder) {
97          return builder.getTraversal().getVisited();
98      }
99  
100     private static String identityDetailPrefix(final Object object) {
101         return ObjectUtils.identityToString(object) + "[";
102     }
103 
104     static Stream<Consumer<ToStringBuilder>> primitiveAppenders() {
105         // @formatter:off
106         return Stream.of(
107                 builder -> builder.append(true),
108                 builder -> builder.append("value", true),
109                 builder -> builder.append(new boolean[] {true}),
110                 builder -> builder.append("value", new boolean[] {true}),
111                 builder -> builder.append("value", new boolean[] {true}, true),
112                 builder -> builder.append((byte) 1),
113                 builder -> builder.append("value", (byte) 1),
114                 builder -> builder.append(new byte[] {1}),
115                 builder -> builder.append("value", new byte[] {1}),
116                 builder -> builder.append("value", new byte[] {1}, true),
117                 builder -> builder.append('a'),
118                 builder -> builder.append("value", 'a'),
119                 builder -> builder.append(new char[] {'a'}),
120                 builder -> builder.append("value", new char[] {'a'}),
121                 builder -> builder.append("value", new char[] {'a'}, true),
122                 builder -> builder.append(1.0),
123                 builder -> builder.append("value", 1.0),
124                 builder -> builder.append(new double[] {1}),
125                 builder -> builder.append("value", new double[] {1}),
126                 builder -> builder.append("value", new double[] {1}, true),
127                 builder -> builder.append(1.0f),
128                 builder -> builder.append("value", 1.0f),
129                 builder -> builder.append(new float[] {1}),
130                 builder -> builder.append("value", new float[] {1}),
131                 builder -> builder.append("value", new float[] {1}, true),
132                 builder -> builder.append(1),
133                 builder -> builder.append("value", 1),
134                 builder -> builder.append(new int[] {1}),
135                 builder -> builder.append("value", new int[] {1}),
136                 builder -> builder.append("value", new int[] {1}, true),
137                 builder -> builder.append(1L),
138                 builder -> builder.append("value", 1L),
139                 builder -> builder.append(new long[] {1}),
140                 builder -> builder.append("value", new long[] {1}),
141                 builder -> builder.append("value", new long[] {1}, true),
142                 builder -> builder.append((short) 1),
143                 builder -> builder.append("value", (short) 1),
144                 builder -> builder.append(new short[] {1}),
145                 builder -> builder.append("value", new short[] {1}),
146                 builder -> builder.append("value", new short[] {1}, true));
147         // @formatter:on
148     }
149 
150     static Stream<ToStringStyle> styles() {
151         return Stream.of(new RecursiveToStringStyle(), new MultilineRecursiveToStringStyle());
152     }
153 
154     private final Object orphan = new Object();
155 
156     @BeforeEach
157     void setUp() {
158         new ReflectionToStringBuilder(orphan, new RecursiveToStringStyle());
159     }
160 
161     @AfterEach
162     void tearDown() {
163         ToStringStyle.unregister(orphan);
164         try {
165             assertNoVisitedObjects();
166         } finally {
167             ToStringStyle.endStyleTraversal(true);
168             ToStringStyle.getDirectTraversals().remove();
169         }
170     }
171 
172     @Test
173     void testAppendFailureReleasesTraversal() {
174         final Object failure = new Object();
175         final ToStringBuilder builder = new ToStringBuilder(new Object(), new FailingStyle(failure));
176         try {
177             assertThrows(IllegalStateException.class, () -> builder.append(new Object[] { new Object(), failure }));
178             assertNoVisitedObjects();
179             assertNull(builderVisited(builder), "A failed append must release the builder's visited objects");
180             builder.toString();
181             assertNull(builderVisited(builder));
182         } finally {
183             ToStringStyle.unregister(builder.getObject());
184         }
185         new ReflectionToStringBuilder(new Object[] { new Object() }, new RecursiveToStringStyle()).toString();
186         assertNoVisitedObjects();
187     }
188 
189     @ParameterizedTest
190     @MethodSource("styles")
191     void testAppendsBeforeReflectionToString(final ToStringStyle style) {
192         final Object shared = new Object();
193         for (int i = 0; i < 10; i++) {
194             final ReflectionToStringBuilder builder = new ReflectionToStringBuilder(new Object[] { shared, new Object() }, style);
195             builder.append("extra", shared);
196             assertNoVisitedObjects();
197             assertEquals(1, StringUtils.countMatches(builder.toString(), identityDetailPrefix(shared)));
198             assertNoVisitedObjects();
199             assertNull(builderVisited(builder));
200         }
201         assertEquals(1, ToStringStyle.getRegistry().size());
202     }
203 
204     @ParameterizedTest
205     @MethodSource("styles")
206     void testBuilderAndDirectStyleAppendsShareVisitedObjects(final ToStringStyle style) {
207         final Object shared = new Object();
208         final ToStringBuilder builder = new ToStringBuilder(new Object(), style).append(shared);
209         style.append(builder.getStringBuffer(), "direct", shared, Boolean.TRUE);
210         final String result = builder.append(shared).toString();
211         assertEquals(1, StringUtils.countMatches(result, identityDetailPrefix(shared)));
212         assertNull(builderVisited(builder));
213         assertNoVisitedObjects();
214     }
215 
216     @Test
217     void testCollectedVisitedReferencesAreRemoved() {
218         final ToStringBuilder builder = new ToStringBuilder(new Object(), new RecursiveToStringStyle());
219         builder.append(new Object());
220         final Set<?> visited = builderVisited(builder);
221         final Reference<?> reference = (Reference<?>) visited.iterator().next();
222         // Exercise queue cleanup deterministically without depending on the garbage collector's scheduling.
223         reference.clear();
224         reference.enqueue();
225         final Object next = new Object();
226         builder.append(next);
227         assertEquals(1, visited.size());
228         assertEquals(1, StringUtils.countMatches(builder.toString(), identityDetailPrefix(next)));
229         assertNoVisitedObjects();
230     }
231 
232     @Test
233     void testCompletionFailureReleasesTraversal() {
234         final Object root = new Object();
235         final ToStringStyle style = new RecursiveToStringStyle() {
236 
237             private static final long serialVersionUID = 1L;
238 
239             @Override
240             public void appendEnd(final StringBuffer buffer, final Object object) {
241                 if (object == root) {
242                     throw new IllegalStateException("Cannot complete output");
243                 }
244                 super.appendEnd(buffer, object);
245             }
246         };
247         final ToStringBuilder builder = new ToStringBuilder(root, style);
248         try {
249             builder.append(new Object[] { new Object() });
250             assertThrows(IllegalStateException.class, builder::toString);
251             assertNoVisitedObjects();
252             assertNull(builderVisited(builder));
253         } finally {
254             ToStringStyle.unregister(builder.getObject());
255         }
256     }
257 
258     @Test
259     void testConstructorCallbackSharesVisitedObjects() {
260         final Object root = new Object();
261         final Object shared = new Object();
262         final ToStringStyle style = new RecursiveToStringStyle() {
263 
264             private static final long serialVersionUID = 1L;
265 
266             @Override
267             public void appendStart(final StringBuffer buffer, final Object object) {
268                 super.appendStart(buffer, object);
269                 if (object == root) {
270                     append(buffer, "prefix", shared, Boolean.TRUE);
271                 }
272             }
273         };
274         final ToStringBuilder builder = new ToStringBuilder(root, style);
275         assertNoVisitedObjects();
276         assertEquals(1, StringUtils.countMatches(builder.append(shared).toString(), identityDetailPrefix(shared)));
277         assertNoVisitedObjects();
278     }
279 
280     @Test
281     void testConstructorFailureReleasesTraversal() {
282         final Object root = new Object();
283         final ToStringStyle style = new RecursiveToStringStyle() {
284 
285             private static final long serialVersionUID = 1L;
286 
287             @Override
288             public void appendStart(final StringBuffer buffer, final Object object) {
289                 super.appendStart(buffer, object);
290                 if (object == root) {
291                     append(buffer, "prefix", new Object(), Boolean.TRUE);
292                     throw new IllegalStateException("Cannot start output");
293                 }
294             }
295         };
296         try {
297             assertThrows(IllegalStateException.class, () -> new ToStringBuilder(root, style));
298             assertNoVisitedObjects();
299         } finally {
300             ToStringStyle.unregister(root);
301         }
302     }
303 
304     @ParameterizedTest
305     @MethodSource("primitiveAppenders")
306     void testCustomPrimitiveFormattingSharesVisitedObjects(final Consumer<ToStringBuilder> appender) {
307         final Object shared = new Object();
308         final ToStringStyle style = new RecursiveToStringStyle() {
309 
310             private static final long serialVersionUID = 1L;
311 
312             @Override
313             protected void appendFieldStart(final StringBuffer buffer, final String fieldName) {
314                 super.appendFieldStart(buffer, fieldName);
315                 appendInternal(buffer, fieldName, shared, true);
316             }
317         };
318         final ToStringBuilder builder = new ToStringBuilder(new Object(), style).append(shared);
319         appender.accept(builder);
320         assertNoVisitedObjects();
321         assertEquals(1, StringUtils.countMatches(builder.toString(), identityDetailPrefix(shared)));
322     }
323 
324     @Test
325     void testCustomSuperAndToStringFormattingShareVisitedObjects() {
326         final Object shared = new Object();
327         final ToStringStyle style = new RecursiveToStringStyle() {
328 
329             private static final long serialVersionUID = 1L;
330 
331             @Override
332             public void appendSuper(final StringBuffer buffer, final String superToString) {
333                 appendInternal(buffer, null, shared, true);
334             }
335 
336             @Override
337             public void appendToString(final StringBuffer buffer, final String toString) {
338                 appendInternal(buffer, null, shared, true);
339             }
340         };
341         final ToStringBuilder builder = new ToStringBuilder(new Object(), style).append(shared);
342         builder.appendSuper("super").appendToString("delegate");
343         assertNoVisitedObjects();
344         assertEquals(1, StringUtils.countMatches(builder.toString(), identityDetailPrefix(shared)));
345     }
346 
347     @Test
348     void testDirectArrayAppendKeepsTraversalActiveBetweenItems() {
349         final RecursiveToStringStyle style = new RecursiveToStringStyle() {
350 
351             private static final long serialVersionUID = 1L;
352 
353             @Override
354             protected void appendDetail(final StringBuffer buffer, final String fieldName, final int index, final Object value) {
355                 assertNotNull(ToStringStyle.getActiveTraversal(), "The array traversal must survive between items, even without appendStart()");
356                 super.appendDetail(buffer, fieldName, index, value);
357             }
358         };
359         final Object shared = new Object();
360         final StringBuffer buffer = new StringBuffer();
361         style.append(buffer, "array", new Object[] { shared, shared }, Boolean.TRUE);
362         assertEquals(1, StringUtils.countMatches(buffer, identityDetailPrefix(shared)));
363         assertNoVisitedObjects();
364     }
365 
366     @ParameterizedTest
367     @MethodSource("styles")
368     void testDirectStyleAppendThenBuilderCompletion(final ToStringStyle style) {
369         for (int i = 0; i < 100; i++) {
370             final Object shared = new Object();
371             final ToStringBuilder builder = new ToStringBuilder(new Object(), style);
372             style.append(builder.getStringBuffer(), "direct", shared, Boolean.TRUE);
373             final String result = builder.append(shared).toString();
374             assertEquals(1, StringUtils.countMatches(result, identityDetailPrefix(shared)));
375             assertNull(builderVisited(builder));
376             assertNoVisitedObjects();
377         }
378         assertEquals(1, ToStringStyle.getRegistry().size());
379     }
380 
381     @Test
382     void testDirectStyleAppendThenBuilderCompletionWithoutOrphan() {
383         ToStringStyle.unregister(orphan);
384         for (int i = 0; i < 100; i++) {
385             final ToStringBuilder builder = new ToStringBuilder(new Object(), new RecursiveToStringStyle());
386             builder.getStyle().append(builder.getStringBuffer(), "direct", new Object(), Boolean.TRUE);
387             builder.toString();
388             assertNull(builderVisited(builder));
389             assertNoVisitedObjects();
390         }
391         assertTrue(ToStringStyle.getRegistry().isEmpty());
392     }
393 
394     @ParameterizedTest
395     @MethodSource("styles")
396     void testDirectStyleCallsKeepSharedReferences(final ToStringStyle style) {
397         final Object shared = new Object();
398         Object graph = shared;
399         for (int i = 0; i < 20; i++) {
400             graph = new Object[] { graph, graph };
401         }
402         final StringBuffer buffer = new StringBuffer();
403         final Object root = new Object();
404         try {
405             style.appendStart(buffer, root);
406             style.append(buffer, "graph", new Object[] { graph, graph }, Boolean.TRUE);
407             style.appendEnd(buffer, root);
408             assertEquals(1, StringUtils.countMatches(buffer, identityDetailPrefix(shared)));
409             assertTrue(buffer.length() < 10_000, "Shared references must not be expanded repeatedly");
410             assertNoVisitedObjects();
411         } finally {
412             ToStringStyle.unregister(root);
413         }
414     }
415 
416     @Test
417     void testDirectStyleCompletionReleasesBuilderState() {
418         final ToStringBuilder builder = new ToStringBuilder(new Object(), new RecursiveToStringStyle()).append(new Object());
419         builder.getStyle().appendEnd(builder.getStringBuffer(), builder.getObject());
420         assertNull(builderVisited(builder));
421         assertNoVisitedObjects();
422     }
423 
424     @Test
425     void testDirectStyleStateSurvivesFailedBuilder() {
426         final Object shared = new Object();
427         final Object root = new Object();
428         final Object failure = new Object();
429         final Object[] failedRoot = { new Object(), failure };
430         final RecursiveToStringStyle style = new RecursiveToStringStyle();
431         final StringBuffer buffer = new StringBuffer();
432         try {
433             style.appendStart(buffer, root);
434             style.append(buffer, "first", shared, Boolean.TRUE);
435             assertThrows(IllegalStateException.class, () -> new ReflectionToStringBuilder(failedRoot, new FailingStyle(failure)).toString());
436             style.append(buffer, "second", shared, Boolean.TRUE);
437             style.appendEnd(buffer, root);
438             assertEquals(1, StringUtils.countMatches(buffer, identityDetailPrefix(shared)));
439             assertNoVisitedObjects();
440         } finally {
441             ToStringStyle.unregister(root);
442             ToStringStyle.unregister(failedRoot);
443         }
444     }
445 
446     @ParameterizedTest
447     @MethodSource("styles")
448     void testDirectStyleStateSurvivesIndependentBuilder(final ToStringStyle style) {
449         final Object shared = new Object();
450         final Object root = new Object();
451         final StringBuffer buffer = new StringBuffer();
452         try {
453             style.appendStart(buffer, root);
454             style.append(buffer, "first", shared, Boolean.TRUE);
455             new ReflectionToStringBuilder(new Object[] { new Object() }, new RecursiveToStringStyle()).toString();
456             style.append(buffer, "second", shared, Boolean.TRUE);
457             style.appendEnd(buffer, root);
458             assertEquals(1, StringUtils.countMatches(buffer, identityDetailPrefix(shared)));
459             assertNoVisitedObjects();
460         } finally {
461             ToStringStyle.unregister(root);
462         }
463     }
464 
465     @ParameterizedTest
466     @MethodSource("styles")
467     void testInterleavedBuildersKeepIndependentVisitedObjects(final ToStringStyle style) {
468         final Object shared = new Object();
469         final ToStringBuilder first = new ToStringBuilder(new Object(), style).append(shared);
470         final ToStringBuilder second = new ToStringBuilder(new Object(), style).append(shared);
471         assertEquals(1, StringUtils.countMatches(first.append(shared).toString(), identityDetailPrefix(shared)));
472         assertEquals(1, StringUtils.countMatches(second.append(shared).toString(), identityDetailPrefix(shared)));
473         assertNoVisitedObjects();
474     }
475 
476     @ParameterizedTest
477     @MethodSource("styles")
478     void testInterleavedDirectStyleOutputs(final ToStringStyle style) {
479         final Object shared = new Object();
480         final Object firstRoot = new Object();
481         final Object secondRoot = new Object();
482         final StringBuffer first = new StringBuffer();
483         final StringBuffer second = new StringBuffer();
484         try {
485             style.appendStart(first, firstRoot);
486             style.append(first, "first", shared, Boolean.TRUE);
487             style.appendStart(second, secondRoot);
488             style.append(second, "first", shared, Boolean.TRUE);
489             style.append(first, "second", shared, Boolean.TRUE);
490             style.appendEnd(first, firstRoot);
491             style.append(second, "second", shared, Boolean.TRUE);
492             style.appendEnd(second, secondRoot);
493             assertEquals(1, StringUtils.countMatches(first, identityDetailPrefix(shared)));
494             assertEquals(1, StringUtils.countMatches(second, identityDetailPrefix(shared)));
495             assertNoVisitedObjects();
496         } finally {
497             ToStringStyle.unregister(firstRoot);
498             ToStringStyle.unregister(secondRoot);
499         }
500     }
501 
502     @ParameterizedTest
503     @MethodSource("appenders")
504     void testManualAppendsReleaseTraversal(final BiConsumer<ToStringBuilder, Object[]> appender) {
505         for (int i = 0; i < 10; i++) {
506             final Object shared = new Object();
507             final ToStringBuilder builder = new ToStringBuilder(new Object(), new RecursiveToStringStyle());
508             appender.accept(builder, new Object[] { shared, shared });
509             assertNoVisitedObjects();
510             appender.accept(builder, new Object[] { shared });
511             assertEquals(1, StringUtils.countMatches(builder.toString(), identityDetailPrefix(shared)));
512             assertNoVisitedObjects();
513             assertNull(builderVisited(builder));
514         }
515         assertEquals(1, ToStringStyle.getRegistry().size());
516     }
517 
518     @ParameterizedTest
519     @MethodSource("styles")
520     void testNestedBuildersKeepSharedReferences(final ToStringStyle style) {
521         final Object shared = new Object();
522         final Object[] root = { new Object(), shared, new Object[] { shared } };
523         final String result = new ReflectionToStringBuilder(root, style).toString();
524         assertEquals(1, StringUtils.countMatches(result, identityDetailPrefix(shared)));
525         assertNoVisitedObjects();
526     }
527 
528     @Test
529     void testNestedBuilderWithEarlierAppends() {
530         final Object shared = new Object();
531         final ReflectionToStringBuilder nested = new ReflectionToStringBuilder(new Object[] { shared }, new RecursiveToStringStyle());
532         nested.append(shared);
533         final ToStringBuilder outer = new ToStringBuilder(new Object());
534         final String result = outer.append(nested).toString();
535         assertEquals(1, StringUtils.countMatches(result, identityDetailPrefix(shared)));
536         assertNoVisitedObjects();
537         assertNull(builderVisited(nested));
538     }
539 
540     @Test
541     void testNestedBuilderWithEarlierAppendsJoinsVisitedObjects() {
542         final Object shared = new Object();
543         final ReflectionToStringBuilder nested = new ReflectionToStringBuilder(new Object[] { shared }, new RecursiveToStringStyle());
544         nested.append(shared);
545         final RecursiveToStringStyle style = new RecursiveToStringStyle() {
546 
547             private static final long serialVersionUID = 1L;
548 
549             @Override
550             protected boolean accept(final Class<?> clazz) {
551                 return clazz != ReflectionToStringBuilder.class && super.accept(clazz);
552             }
553         };
554         final ToStringBuilder outer = new ToStringBuilder(new Object(), style).append(new Object());
555         final String result = outer.append(nested).append(shared).toString();
556         assertEquals(1, StringUtils.countMatches(result, identityDetailPrefix(shared)));
557         assertNoVisitedObjects();
558     }
559 
560     @Test
561     void testNullReflectionCompletionReleasesEarlierAppends() {
562         final ReflectionToStringBuilder builder = new ReflectionToStringBuilder(null, new RecursiveToStringStyle());
563         builder.append(new Object[] { new Object() });
564         assertEquals("<null>", builder.toString());
565         assertNoVisitedObjects();
566         assertNull(builderVisited(builder));
567     }
568 
569     @Test
570     void testOrphanWithEarlierAppendDoesNotPolluteLaterBuilders() {
571         new ReflectionToStringBuilder(orphan, new RecursiveToStringStyle()).append(new Object[] { new Object() });
572         for (int i = 0; i < 10; i++) {
573             new ReflectionToStringBuilder(new Object[] { new Object() }, new RecursiveToStringStyle()).toString();
574             assertNoVisitedObjects();
575         }
576     }
577 
578     @ParameterizedTest
579     @MethodSource("styles")
580     void testReflectionArrayAppendSharesVisitedObjects(final ToStringStyle style) {
581         final Object shared = new Object();
582         final ReflectionToStringBuilder builder = new ReflectionToStringBuilder(new Object[] { shared }, style);
583         builder.reflectionAppendArray(new Object[] { shared });
584         assertNoVisitedObjects();
585         assertEquals(1, StringUtils.countMatches(builder.toString(), identityDetailPrefix(shared)));
586         assertNoVisitedObjects();
587     }
588 
589     @Test
590     void testReflectionFailureReleasesTraversal() {
591         final Object failure = new Object();
592         final Object[] root = { new Object(), failure };
593         final ReflectionToStringBuilder builder = new ReflectionToStringBuilder(root, new FailingStyle(failure));
594         try {
595             assertThrows(IllegalStateException.class, builder::toString);
596             assertNoVisitedObjects();
597             assertNull(builderVisited(builder));
598         } finally {
599             ToStringStyle.unregister(root);
600         }
601     }
602 
603     @Test
604     void testShallowBuilderDoesNotAllocateVisitedMap() {
605         final ToStringBuilder builder = new ToStringBuilder(new Object());
606         builder.append(new Object());
607         assertNull(builderVisited(builder));
608         builder.toString();
609         assertNoVisitedObjects();
610     }
611 
612     @Test
613     void testValidationFailureReleasesEarlierAppends() {
614         final ReflectionToStringBuilder builder = new ReflectionToStringBuilder(new Object(), new RecursiveToStringStyle());
615         builder.append(new Object());
616         builder.setIncludeFieldNames("value").setExcludeFieldNames("value");
617         assertThrows(IllegalStateException.class, builder::toString);
618         assertNoVisitedObjects();
619         assertNull(builderVisited(builder));
620     }
621 
622     @ParameterizedTest
623     @MethodSource("styles")
624     void testVisitedObjectsUseIdentityWithoutCallingObjectMethods(final ToStringStyle style) {
625         final Object first = new IdentityOnly();
626         final Object second = new IdentityOnly();
627         final String result = new ToStringBuilder(new Object(), style).append(new Object[] { first, second, first }).toString();
628         assertEquals(1, StringUtils.countMatches(result, identityDetailPrefix(first)));
629         assertEquals(1, StringUtils.countMatches(result, identityDetailPrefix(second)));
630         assertNoVisitedObjects();
631     }
632 }