Imported Upstream version 1.7.20
Emmanuel Bourg
7 years ago
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 | <artifactId>integration</artifactId> |
4 | 4 | <parent> |
5 | 5 | <groupId>org.slf4j</groupId> |
6 | 6 | <artifactId>slf4j-parent</artifactId> |
7 | <version>1.7.19</version> | |
7 | <version>1.7.20</version> | |
8 | 8 | </parent> |
9 | 9 | |
10 | 10 | <modelVersion>4.0.0</modelVersion> |
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 | <artifactId>jul-to-slf4j</artifactId> |
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 |
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 | <artifactId>osgi-over-slf4j</artifactId> |
5 | 5 | |
6 | 6 | <groupId>org.slf4j</groupId> |
7 | 7 | <artifactId>slf4j-parent</artifactId> |
8 | <version>1.7.19</version> | |
8 | <version>1.7.20</version> | |
9 | 9 | |
10 | 10 | <packaging>pom</packaging> |
11 | 11 | <name>SLF4J</name> |
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 | <artifactId>slf4j-android</artifactId> |
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 | <artifactId>slf4j-api</artifactId> |
239 | 239 | |
240 | 240 | private static void emitReplayWarning(int eventCount) { |
241 | 241 | Util.report("A number (" + eventCount + ") of logging calls during the initialization phase have been intercepted and are"); |
242 | Util.report("now being replayed. These are suject to the filtering rules of the underlying logging system."); | |
242 | Util.report("now being replayed. These are subject to the filtering rules of the underlying logging system."); | |
243 | 243 | Util.report("See also " + REPLAY_URL); |
244 | 244 | } |
245 | 245 |
0 | /** | |
1 | * Copyright (c) 2004-2016 QOS.ch | |
2 | * All rights reserved. | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining | |
5 | * a copy of this software and associated documentation files (the | |
6 | * "Software"), to deal in the Software without restriction, including | |
7 | * without limitation the rights to use, copy, modify, merge, publish, | |
8 | * distribute, sublicense, and/or sell copies of the Software, and to | |
9 | * permit persons to whom the Software is furnished to do so, subject to | |
10 | * the following conditions: | |
11 | * | |
12 | * The above copyright notice and this permission notice shall be | |
13 | * included in all copies or substantial portions of the Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
16 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
17 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
18 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | |
19 | * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | |
20 | * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
21 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
22 | * | |
23 | */ | |
24 | package org.slf4j; | |
25 | ||
26 | import java.util.concurrent.CyclicBarrier; | |
27 | import java.util.concurrent.atomic.AtomicLong; | |
28 | ||
29 | public class LoggerAccessingThread extends Thread { | |
30 | private static int LOOP_LEN = 64; | |
31 | ||
32 | final CyclicBarrier barrier; | |
33 | final int count; | |
34 | final AtomicLong eventCount; | |
35 | ||
36 | public LoggerAccessingThread(final CyclicBarrier barrier, final int count, final AtomicLong eventCount) { | |
37 | this.barrier = barrier; | |
38 | this.count = count; | |
39 | this.eventCount = eventCount; | |
40 | } | |
41 | ||
42 | public void run() { | |
43 | try { | |
44 | barrier.await(); | |
45 | } catch (Exception e) { | |
46 | e.printStackTrace(); | |
47 | } | |
48 | ||
49 | String loggerNamePrefix = this.getClass().getName(); | |
50 | for (int i = 0; i < LOOP_LEN; i++) { | |
51 | Logger logger = LoggerFactory.getLogger(loggerNamePrefix + "-" + count + "-" + i); | |
52 | logger.info("in run method"); | |
53 | eventCount.getAndIncrement(); | |
54 | } | |
55 | } | |
56 | } |
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 | <artifactId>slf4j-ext</artifactId> |
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 | <artifactId>slf4j-jcl</artifactId> |
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 | <artifactId>slf4j-jdk14</artifactId> |
42 | 42 | |
43 | 43 | public JDK14LoggerFactory() { |
44 | 44 | loggerMap = new ConcurrentHashMap<String, Logger>(); |
45 | // ensure jul initialization. see also SLF4J-359 | |
46 | java.util.logging.LogManager.getLogManager(); | |
45 | // ensure jul initialization. see SLF4J-359 | |
46 | // note that call to java.util.logging.LogManager.getLogManager() fails on the Google App Engine platform. See SLF4J-363 | |
47 | java.util.logging.Logger.getLogger(""); | |
47 | 48 | } |
48 | 49 | |
49 | 50 | /* |
0 | package org.slf4j.impl; | |
1 | ||
2 | import java.util.concurrent.atomic.AtomicLong; | |
3 | import java.util.logging.Handler; | |
4 | import java.util.logging.LogRecord; | |
5 | ||
6 | public class CountingHandler extends Handler { | |
7 | ||
8 | final AtomicLong eventCount = new AtomicLong(0); | |
9 | ||
10 | @Override | |
11 | public void publish(LogRecord record) { | |
12 | eventCount.getAndIncrement(); | |
13 | } | |
14 | ||
15 | @Override | |
16 | public void flush() { | |
17 | } | |
18 | ||
19 | @Override | |
20 | public void close() throws SecurityException { | |
21 | } | |
22 | ||
23 | } |
+123
-0
0 | /** | |
1 | * Copyright (c) 2004-2016 QOS.ch | |
2 | * All rights reserved. | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining | |
5 | * a copy of this software and associated documentation files (the | |
6 | * "Software"), to deal in the Software without restriction, including | |
7 | * without limitation the rights to use, copy, modify, merge, publish, | |
8 | * distribute, sublicense, and/or sell copies of the Software, and to | |
9 | * permit persons to whom the Software is furnished to do so, subject to | |
10 | * the following conditions: | |
11 | * | |
12 | * The above copyright notice and this permission notice shall be | |
13 | * included in all copies or substantial portions of the Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
16 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
17 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
18 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | |
19 | * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | |
20 | * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
21 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
22 | * | |
23 | */ | |
24 | package org.slf4j.impl; | |
25 | ||
26 | import static org.junit.Assert.assertTrue; | |
27 | import static org.junit.Assert.fail; | |
28 | ||
29 | import java.util.Random; | |
30 | import java.util.concurrent.BrokenBarrierException; | |
31 | import java.util.concurrent.CyclicBarrier; | |
32 | import java.util.concurrent.atomic.AtomicLong; | |
33 | import java.util.logging.Handler; | |
34 | ||
35 | import org.junit.After; | |
36 | import org.junit.Before; | |
37 | import org.junit.Test; | |
38 | import org.slf4j.Logger; | |
39 | import org.slf4j.LoggerAccessingThread; | |
40 | import org.slf4j.LoggerFactory; | |
41 | ||
42 | public class JDK14MultithreadedInitializationTest { | |
43 | ||
44 | final static int THREAD_COUNT = 4 + Runtime.getRuntime().availableProcessors() * 2; | |
45 | ||
46 | final private AtomicLong eventCount = new AtomicLong(0); | |
47 | final private CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT + 1); | |
48 | ||
49 | int diff = new Random().nextInt(10000); | |
50 | ||
51 | java.util.logging.Logger julRootLogger = java.util.logging.Logger.getLogger(""); | |
52 | java.util.logging.Logger julOrgLogger = java.util.logging.Logger.getLogger("org"); | |
53 | ||
54 | @Before | |
55 | public void addRecordingHandler() { | |
56 | System.out.println("THREAD_COUNT=" + THREAD_COUNT); | |
57 | removeAllHandlers(julRootLogger); | |
58 | removeAllHandlers(julOrgLogger); | |
59 | julOrgLogger.addHandler(new CountingHandler()); | |
60 | } | |
61 | ||
62 | private void removeAllHandlers(java.util.logging.Logger logger) { | |
63 | Handler[] handlers = logger.getHandlers(); | |
64 | for (int i = 0; i < handlers.length; i++) { | |
65 | logger.removeHandler(handlers[i]); | |
66 | } | |
67 | } | |
68 | ||
69 | @After | |
70 | public void tearDown() throws Exception { | |
71 | removeAllHandlers(julOrgLogger); | |
72 | } | |
73 | ||
74 | @Test | |
75 | public void multiThreadedInitialization() throws InterruptedException, BrokenBarrierException { | |
76 | @SuppressWarnings("unused") | |
77 | LoggerAccessingThread[] accessors = harness(); | |
78 | ||
79 | Logger logger = LoggerFactory.getLogger(getClass().getName()); | |
80 | logger.info("hello"); | |
81 | eventCount.getAndIncrement(); | |
82 | ||
83 | long recordedEventCount = getRecordedEventCount(); | |
84 | assertTrue(eventCount.get() + " >= " + recordedEventCount, eventCount.get() >= recordedEventCount); | |
85 | assertTrue(eventCount.get() + " < " + recordedEventCount + "+10", eventCount.get() < recordedEventCount + 10); | |
86 | } | |
87 | ||
88 | private long getRecordedEventCount() { | |
89 | CountingHandler ra = findRecordingHandler(); | |
90 | if (ra == null) { | |
91 | fail("failed to fing RecordingHandler"); | |
92 | } | |
93 | return ra.eventCount.get(); | |
94 | } | |
95 | ||
96 | private CountingHandler findRecordingHandler() { | |
97 | Handler[] handlers = julOrgLogger.getHandlers(); | |
98 | for (Handler h : handlers) { | |
99 | if (h instanceof CountingHandler) | |
100 | return (CountingHandler) h; | |
101 | } | |
102 | return null; | |
103 | } | |
104 | ||
105 | private LoggerAccessingThread[] harness() throws InterruptedException, BrokenBarrierException { | |
106 | LoggerAccessingThread[] threads = new LoggerAccessingThread[THREAD_COUNT]; | |
107 | for (int i = 0; i < THREAD_COUNT; i++) { | |
108 | threads[i] = new LoggerAccessingThread(barrier, i, eventCount); | |
109 | threads[i].start(); | |
110 | } | |
111 | ||
112 | // trigger barrier | |
113 | barrier.await(); | |
114 | ||
115 | for (int i = 0; i < THREAD_COUNT; i++) { | |
116 | threads[i].join(); | |
117 | } | |
118 | ||
119 | return threads; | |
120 | } | |
121 | ||
122 | } |
0 | /** | |
1 | * Copyright (c) 2004-2016 QOS.ch | |
2 | * All rights reserved. | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining | |
5 | * a copy of this software and associated documentation files (the | |
6 | * "Software"), to deal in the Software without restriction, including | |
7 | * without limitation the rights to use, copy, modify, merge, publish, | |
8 | * distribute, sublicense, and/or sell copies of the Software, and to | |
9 | * permit persons to whom the Software is furnished to do so, subject to | |
10 | * the following conditions: | |
11 | * | |
12 | * The above copyright notice and this permission notice shall be | |
13 | * included in all copies or substantial portions of the Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
16 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
17 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
18 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | |
19 | * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | |
20 | * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
21 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
22 | * | |
23 | */ | |
24 | package org.slf4j.impl; | |
25 | ||
26 | import static org.junit.Assert.assertEquals; | |
27 | import static org.junit.Assert.fail; | |
28 | ||
29 | import java.util.List; | |
30 | import java.util.Random; | |
31 | import java.util.concurrent.BrokenBarrierException; | |
32 | import java.util.concurrent.CyclicBarrier; | |
33 | import java.util.concurrent.atomic.AtomicLong; | |
34 | import java.util.logging.Handler; | |
35 | import java.util.logging.LogRecord; | |
36 | ||
37 | import org.junit.After; | |
38 | import org.junit.Before; | |
39 | import org.junit.Test; | |
40 | import org.slf4j.Logger; | |
41 | import org.slf4j.LoggerFactory; | |
42 | ||
43 | public class MultithreadedInitializationTest { | |
44 | ||
45 | final static int THREAD_COUNT = 4 + Runtime.getRuntime().availableProcessors() * 2; | |
46 | ||
47 | private static AtomicLong EVENT_COUNT = new AtomicLong(0); | |
48 | ||
49 | final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT + 1); | |
50 | ||
51 | int diff = new Random().nextInt(10000); | |
52 | String packagePrefix = "org.slf4j.impl.MultithreadedInitializationTest" + diff; | |
53 | ||
54 | java.util.logging.Logger julLogger = java.util.logging.Logger.getLogger(packagePrefix); | |
55 | ||
56 | @Before | |
57 | public void addRecordingHandler() { | |
58 | julLogger.addHandler(new RecordingHandler()); | |
59 | } | |
60 | ||
61 | @After | |
62 | public void tearDown() throws Exception { | |
63 | Handler[] handlers = julLogger.getHandlers(); | |
64 | for (int i = 0; i < handlers.length; i++) { | |
65 | if (handlers[i] instanceof RecordingHandler) { | |
66 | julLogger.removeHandler(handlers[i]); | |
67 | } | |
68 | } | |
69 | } | |
70 | ||
71 | @Test | |
72 | public void multiThreadedInitialization() throws InterruptedException, BrokenBarrierException { | |
73 | System.out.println("THREAD_COUNT=" + THREAD_COUNT); | |
74 | LoggerAccessingThread[] accessors = harness(); | |
75 | ||
76 | for (int i = 0; i < accessors.length; i++) { | |
77 | LoggerAccessingThread accessor = accessors[i]; | |
78 | EVENT_COUNT.getAndIncrement(); | |
79 | if (accessor.logger == null) { | |
80 | fail("logger for LoggerAccessingThread " + i + " is not set"); | |
81 | } | |
82 | accessor.logger.info("post harness"); | |
83 | } | |
84 | ||
85 | Logger logger = LoggerFactory.getLogger(packagePrefix + ".test"); | |
86 | logger.info("hello"); | |
87 | EVENT_COUNT.getAndIncrement(); | |
88 | ||
89 | List<LogRecord> records = getRecordedEvents(); | |
90 | assertEquals(EVENT_COUNT.get(), records.size()); | |
91 | } | |
92 | ||
93 | private List<LogRecord> getRecordedEvents() { | |
94 | RecordingHandler ra = findRecordingHandler(); | |
95 | if (ra == null) { | |
96 | fail("failed to fing RecordingHandler"); | |
97 | } | |
98 | return ra.records; | |
99 | } | |
100 | ||
101 | private RecordingHandler findRecordingHandler() { | |
102 | Handler[] handlers = julLogger.getHandlers(); | |
103 | for (Handler h : handlers) { | |
104 | if (h instanceof RecordingHandler) | |
105 | return (RecordingHandler) h; | |
106 | } | |
107 | return null; | |
108 | } | |
109 | ||
110 | private LoggerAccessingThread[] harness() throws InterruptedException, BrokenBarrierException { | |
111 | LoggerAccessingThread[] threads = new LoggerAccessingThread[THREAD_COUNT]; | |
112 | final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT + 1); | |
113 | for (int i = 0; i < THREAD_COUNT; i++) { | |
114 | threads[i] = new LoggerAccessingThread(barrier, i); | |
115 | threads[i].start(); | |
116 | } | |
117 | ||
118 | // trigger barrier | |
119 | barrier.await(); | |
120 | ||
121 | for (int i = 0; i < THREAD_COUNT; i++) { | |
122 | threads[i].join(); | |
123 | } | |
124 | ||
125 | return threads; | |
126 | } | |
127 | ||
128 | class LoggerAccessingThread extends Thread { | |
129 | final CyclicBarrier barrier; | |
130 | volatile Logger logger; | |
131 | final int count; | |
132 | ||
133 | LoggerAccessingThread(CyclicBarrier barrier, int count) { | |
134 | this.barrier = barrier; | |
135 | this.count = count; | |
136 | } | |
137 | ||
138 | public void run() { | |
139 | try { | |
140 | barrier.await(); | |
141 | } catch (Exception e) { | |
142 | e.printStackTrace(); | |
143 | } | |
144 | for (int i = 0; i < 64; i++) { | |
145 | logger = LoggerFactory.getLogger(packagePrefix + ".LoggerAccessingThread" + count + "-" + i); | |
146 | logger.info("in run method"); | |
147 | EVENT_COUNT.getAndIncrement(); | |
148 | } | |
149 | } | |
150 | }; | |
151 | ||
152 | } |
0 | package org.slf4j.impl; | |
1 | ||
2 | import java.util.ArrayList; | |
3 | import java.util.Collections; | |
4 | import java.util.List; | |
5 | import java.util.logging.Handler; | |
6 | import java.util.logging.LogRecord; | |
7 | ||
8 | public class RecordingHandler extends Handler { | |
9 | ||
10 | List<LogRecord> records = Collections.synchronizedList(new ArrayList<LogRecord>()); | |
11 | ||
12 | @Override | |
13 | public void publish(LogRecord record) { | |
14 | records.add(record); | |
15 | } | |
16 | ||
17 | @Override | |
18 | public void flush() { | |
19 | } | |
20 | ||
21 | @Override | |
22 | public void close() throws SecurityException { | |
23 | } | |
24 | ||
25 | } |
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 | <artifactId>slf4j-log4j12</artifactId> |
26 | 26 | <groupId>log4j</groupId> |
27 | 27 | <artifactId>log4j</artifactId> |
28 | 28 | </dependency> |
29 | ||
30 | <dependency> | |
31 | <groupId>org.slf4j</groupId> | |
32 | <artifactId>slf4j-api</artifactId> | |
33 | <type>test-jar</type> | |
34 | <version>${project.version}</version> | |
35 | <scope>test</scope> | |
36 | </dependency> | |
29 | 37 | </dependencies> |
30 | 38 | |
31 | 39 | </project>⏎ |
+106
-0
0 | /** | |
1 | * Copyright (c) 2004-2011 QOS.ch | |
2 | * All rights reserved. | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining | |
5 | * a copy of this software and associated documentation files (the | |
6 | * "Software"), to deal in the Software without restriction, including | |
7 | * without limitation the rights to use, copy, modify, merge, publish, | |
8 | * distribute, sublicense, and/or sell copies of the Software, and to | |
9 | * permit persons to whom the Software is furnished to do so, subject to | |
10 | * the following conditions: | |
11 | * | |
12 | * The above copyright notice and this permission notice shall be | |
13 | * included in all copies or substantial portions of the Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
16 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
17 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
18 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | |
19 | * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | |
20 | * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
21 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
22 | * | |
23 | */ | |
24 | package org.slf4j.impl; | |
25 | ||
26 | import static org.junit.Assert.assertEquals; | |
27 | ||
28 | import java.util.List; | |
29 | import java.util.Random; | |
30 | import java.util.concurrent.BrokenBarrierException; | |
31 | import java.util.concurrent.CyclicBarrier; | |
32 | import java.util.concurrent.atomic.AtomicLong; | |
33 | ||
34 | import org.apache.log4j.LogManager; | |
35 | import org.apache.log4j.spi.LoggingEvent; | |
36 | import org.junit.After; | |
37 | import org.junit.Before; | |
38 | import org.junit.Test; | |
39 | import org.slf4j.Logger; | |
40 | import org.slf4j.LoggerAccessingThread; | |
41 | import org.slf4j.LoggerFactory; | |
42 | ||
43 | public class Log4j12MultithreadedInitializationTest { | |
44 | ||
45 | // value of LogManager.DEFAULT_CONFIGURATION_KEY; | |
46 | static String CONFIG_FILE_KEY = "log4j.configuration"; | |
47 | ||
48 | final static int THREAD_COUNT = 4 + Runtime.getRuntime().availableProcessors() * 2; | |
49 | ||
50 | private final AtomicLong eventCount = new AtomicLong(0); | |
51 | ||
52 | private final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT + 1); | |
53 | ||
54 | final int diff = new Random().nextInt(10000); | |
55 | final String loggerName = this.getClass().getName(); | |
56 | ||
57 | @Before | |
58 | public void setup() { | |
59 | System.out.println("THREAD_COUNT=" + THREAD_COUNT); | |
60 | } | |
61 | ||
62 | @After | |
63 | public void tearDown() throws Exception { | |
64 | System.clearProperty(CONFIG_FILE_KEY); | |
65 | } | |
66 | ||
67 | @Test | |
68 | public void multiThreadedInitialization() throws InterruptedException, BrokenBarrierException { | |
69 | ||
70 | System.setProperty(CONFIG_FILE_KEY, "recursiveInitWithActivationDelay.properties"); | |
71 | ||
72 | @SuppressWarnings("unused") | |
73 | LoggerAccessingThread[] accessors = harness(); | |
74 | ||
75 | Logger logger = LoggerFactory.getLogger(loggerName + ".slowInitialization-" + diff); | |
76 | logger.info("hello"); | |
77 | eventCount.getAndIncrement(); | |
78 | ||
79 | List<LoggingEvent> events = getRecordedEvents(); | |
80 | int NUM_LINES_BY_RECURSIVE_APPENDER = 3; | |
81 | assertEquals(eventCount.get() + NUM_LINES_BY_RECURSIVE_APPENDER, events.size()); | |
82 | } | |
83 | ||
84 | private List<LoggingEvent> getRecordedEvents() { | |
85 | org.apache.log4j.Logger root = LogManager.getRootLogger(); | |
86 | ||
87 | RecursiveAppender ra = (RecursiveAppender) root.getAppender("RECURSIVE"); | |
88 | return ra.events; | |
89 | } | |
90 | ||
91 | private LoggerAccessingThread[] harness() throws InterruptedException, BrokenBarrierException { | |
92 | LoggerAccessingThread[] threads = new LoggerAccessingThread[THREAD_COUNT]; | |
93 | for (int i = 0; i < THREAD_COUNT; i++) { | |
94 | threads[i] = new LoggerAccessingThread(barrier, i, eventCount); | |
95 | threads[i].start(); | |
96 | } | |
97 | ||
98 | barrier.await(); | |
99 | for (int i = 0; i < THREAD_COUNT; i++) { | |
100 | threads[i].join(); | |
101 | } | |
102 | return threads; | |
103 | } | |
104 | ||
105 | } |
0 | /** | |
1 | * Copyright (c) 2004-2011 QOS.ch | |
2 | * All rights reserved. | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining | |
5 | * a copy of this software and associated documentation files (the | |
6 | * "Software"), to deal in the Software without restriction, including | |
7 | * without limitation the rights to use, copy, modify, merge, publish, | |
8 | * distribute, sublicense, and/or sell copies of the Software, and to | |
9 | * permit persons to whom the Software is furnished to do so, subject to | |
10 | * the following conditions: | |
11 | * | |
12 | * The above copyright notice and this permission notice shall be | |
13 | * included in all copies or substantial portions of the Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
16 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
17 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
18 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | |
19 | * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | |
20 | * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
21 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
22 | * | |
23 | */ | |
24 | package org.slf4j.impl; | |
25 | ||
26 | import static org.junit.Assert.assertEquals; | |
27 | ||
28 | import java.util.List; | |
29 | import java.util.Random; | |
30 | import java.util.concurrent.BrokenBarrierException; | |
31 | import java.util.concurrent.CyclicBarrier; | |
32 | import java.util.concurrent.atomic.AtomicLong; | |
33 | ||
34 | import org.apache.log4j.LogManager; | |
35 | import org.apache.log4j.spi.LoggingEvent; | |
36 | import org.junit.After; | |
37 | import org.junit.Test; | |
38 | import org.slf4j.Logger; | |
39 | import org.slf4j.LoggerFactory; | |
40 | ||
41 | public class MultithreadedInitializationTest { | |
42 | ||
43 | // value of LogManager.DEFAULT_CONFIGURATION_KEY; | |
44 | static String CONFIG_FILE_KEY = "log4j.configuration"; | |
45 | ||
46 | final static int THREAD_COUNT = 4 + Runtime.getRuntime().availableProcessors() * 2; | |
47 | ||
48 | private static AtomicLong EVENT_COUNT = new AtomicLong(0); | |
49 | ||
50 | final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT + 1); | |
51 | ||
52 | int diff = new Random().nextInt(10000); | |
53 | String loggerName = "org.slf4j.impl.RecursiveInitializationTest"; | |
54 | ||
55 | @After | |
56 | public void tearDown() throws Exception { | |
57 | System.clearProperty(CONFIG_FILE_KEY); | |
58 | } | |
59 | ||
60 | @Test | |
61 | public void multiThreadedInitialization() throws InterruptedException, BrokenBarrierException { | |
62 | System.out.println("THREAD_COUNT=" + THREAD_COUNT); | |
63 | System.setProperty(CONFIG_FILE_KEY, "recursiveInitWithActivationDelay.properties"); | |
64 | LoggerAccessingThread[] accessors = harness(); | |
65 | ||
66 | for (LoggerAccessingThread accessor : accessors) { | |
67 | EVENT_COUNT.getAndIncrement(); | |
68 | accessor.logger.info("post harness"); | |
69 | } | |
70 | ||
71 | Logger logger = LoggerFactory.getLogger(loggerName + ".slowInitialization-" + diff); | |
72 | logger.info("hello"); | |
73 | EVENT_COUNT.getAndIncrement(); | |
74 | ||
75 | List<LoggingEvent> events = getRecordedEvents(); | |
76 | // 3 evetns generated by RecursiveAppender | |
77 | assertEquals(EVENT_COUNT.get() + 3, events.size()); | |
78 | } | |
79 | ||
80 | private List<LoggingEvent> getRecordedEvents() { | |
81 | org.apache.log4j.Logger root = LogManager.getRootLogger(); | |
82 | ||
83 | RecursiveAppender ra = (RecursiveAppender) root.getAppender("RECURSIVE"); | |
84 | return ra.events; | |
85 | } | |
86 | ||
87 | private static LoggerAccessingThread[] harness() throws InterruptedException, BrokenBarrierException { | |
88 | LoggerAccessingThread[] threads = new LoggerAccessingThread[THREAD_COUNT]; | |
89 | final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT + 1); | |
90 | for (int i = 0; i < THREAD_COUNT; i++) { | |
91 | threads[i] = new LoggerAccessingThread(barrier, i); | |
92 | threads[i].start(); | |
93 | } | |
94 | ||
95 | barrier.await(); | |
96 | for (int i = 0; i < THREAD_COUNT; i++) { | |
97 | threads[i].join(); | |
98 | } | |
99 | return threads; | |
100 | } | |
101 | ||
102 | static class LoggerAccessingThread extends Thread { | |
103 | final CyclicBarrier barrier; | |
104 | Logger logger; | |
105 | int count; | |
106 | ||
107 | LoggerAccessingThread(CyclicBarrier barrier, int count) { | |
108 | this.barrier = barrier; | |
109 | this.count = count; | |
110 | } | |
111 | ||
112 | public void run() { | |
113 | try { | |
114 | barrier.await(); | |
115 | } catch (Exception e) { | |
116 | e.printStackTrace(); | |
117 | } | |
118 | for (int i = 0; i < 64; i++) { | |
119 | logger = LoggerFactory.getLogger(this.getClass().getName() + "-" + count + "-" + i); | |
120 | logger.info("in run method"); | |
121 | EVENT_COUNT.getAndIncrement(); | |
122 | } | |
123 | } | |
124 | }; | |
125 | ||
126 | } |
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 | <artifactId>slf4j-migrator</artifactId> |
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 | <artifactId>slf4j-nop</artifactId> |
6 | 6 | <parent> |
7 | 7 | <groupId>org.slf4j</groupId> |
8 | 8 | <artifactId>slf4j-parent</artifactId> |
9 | <version>1.7.19</version> | |
9 | <version>1.7.20</version> | |
10 | 10 | </parent> |
11 | 11 | |
12 | 12 | <artifactId>slf4j-simple</artifactId> |
20 | 20 | <groupId>org.slf4j</groupId> |
21 | 21 | <artifactId>slf4j-api</artifactId> |
22 | 22 | </dependency> |
23 | ||
24 | <dependency> | |
25 | <groupId>org.slf4j</groupId> | |
26 | <artifactId>slf4j-api</artifactId> | |
27 | <type>test-jar</type> | |
28 | <version>${project.version}</version> | |
29 | <scope>test</scope> | |
30 | </dependency> | |
23 | 31 | </dependencies> |
24 | 32 | |
25 | 33 | </project>⏎ |
0 | /** | |
1 | * Copyright (c) 2004-2016 QOS.ch | |
2 | * All rights reserved. | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining | |
5 | * a copy of this software and associated documentation files (the | |
6 | * "Software"), to deal in the Software without restriction, including | |
7 | * without limitation the rights to use, copy, modify, merge, publish, | |
8 | * distribute, sublicense, and/or sell copies of the Software, and to | |
9 | * permit persons to whom the Software is furnished to do so, subject to | |
10 | * the following conditions: | |
11 | * | |
12 | * The above copyright notice and this permission notice shall be | |
13 | * included in all copies or substantial portions of the Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
16 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
17 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
18 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | |
19 | * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | |
20 | * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
21 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
22 | * | |
23 | */ | |
24 | package org.slf4j.impl; | |
25 | ||
26 | import static org.junit.Assert.assertEquals; | |
27 | ||
28 | import java.io.PrintStream; | |
29 | import java.util.ArrayList; | |
30 | import java.util.Collections; | |
31 | import java.util.List; | |
32 | import java.util.Random; | |
33 | import java.util.concurrent.BrokenBarrierException; | |
34 | import java.util.concurrent.CyclicBarrier; | |
35 | import java.util.concurrent.atomic.AtomicLong; | |
36 | ||
37 | import org.junit.After; | |
38 | import org.junit.Before; | |
39 | import org.junit.Test; | |
40 | import org.slf4j.Logger; | |
41 | import org.slf4j.LoggerFactory; | |
42 | import org.slf4j.LoggerFactoryFriend; | |
43 | ||
44 | public class MultithreadedInitializationTest { | |
45 | ||
46 | final static int THREAD_COUNT = 4 + Runtime.getRuntime().availableProcessors() * 2; | |
47 | ||
48 | private static AtomicLong EVENT_COUNT = new AtomicLong(0); | |
49 | ||
50 | private final PrintStream oldErr = System.err; | |
51 | final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT + 1); | |
52 | ||
53 | int diff = new Random().nextInt(10000); | |
54 | String loggerName = "org.slf4j.impl.MultithreadedInitializationTest"; | |
55 | StringPrintStream sps = new StringPrintStream(oldErr); | |
56 | ||
57 | @Before | |
58 | public void setup() { | |
59 | LoggerFactoryFriend.reset(); | |
60 | System.setErr(sps); | |
61 | } | |
62 | ||
63 | @After | |
64 | public void tearDown() throws Exception { | |
65 | LoggerFactoryFriend.reset(); | |
66 | System.setErr(oldErr); | |
67 | } | |
68 | ||
69 | @Test | |
70 | public void multiThreadedInitialization() throws InterruptedException, BrokenBarrierException { | |
71 | System.out.println("THREAD_COUNT=" + THREAD_COUNT); | |
72 | LoggerAccessingThread[] accessors = harness(); | |
73 | ||
74 | for (LoggerAccessingThread accessor : accessors) { | |
75 | EVENT_COUNT.getAndIncrement(); | |
76 | accessor.logger.info("post harness"); | |
77 | } | |
78 | ||
79 | Logger logger = LoggerFactory.getLogger(loggerName + ".slowInitialization-" + diff); | |
80 | logger.info("hello"); | |
81 | EVENT_COUNT.getAndIncrement(); | |
82 | ||
83 | int NUM_LINES_IN_SLF4J_REPLAY_WARNING = 3; | |
84 | assertEquals(EVENT_COUNT.get() + NUM_LINES_IN_SLF4J_REPLAY_WARNING, sps.stringList.size()); | |
85 | } | |
86 | ||
87 | private static LoggerAccessingThread[] harness() throws InterruptedException, BrokenBarrierException { | |
88 | LoggerAccessingThread[] threads = new LoggerAccessingThread[THREAD_COUNT]; | |
89 | final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT + 1); | |
90 | for (int i = 0; i < THREAD_COUNT; i++) { | |
91 | threads[i] = new LoggerAccessingThread(barrier, i); | |
92 | threads[i].start(); | |
93 | } | |
94 | ||
95 | barrier.await(); | |
96 | for (int i = 0; i < THREAD_COUNT; i++) { | |
97 | threads[i].join(); | |
98 | } | |
99 | return threads; | |
100 | } | |
101 | ||
102 | static class LoggerAccessingThread extends Thread { | |
103 | final CyclicBarrier barrier; | |
104 | Logger logger; | |
105 | int count; | |
106 | ||
107 | LoggerAccessingThread(CyclicBarrier barrier, int count) { | |
108 | this.barrier = barrier; | |
109 | this.count = count; | |
110 | } | |
111 | ||
112 | public void run() { | |
113 | try { | |
114 | barrier.await(); | |
115 | } catch (Exception e) { | |
116 | e.printStackTrace(); | |
117 | } | |
118 | for (int i = 0; i < 64; i++) { | |
119 | logger = LoggerFactory.getLogger(this.getClass().getName() + "-" + count+"-"+i); | |
120 | logger.info("in run method"); | |
121 | EVENT_COUNT.getAndIncrement(); | |
122 | } | |
123 | } | |
124 | }; | |
125 | ||
126 | public static class StringPrintStream extends PrintStream { | |
127 | ||
128 | public static final String LINE_SEP = System.getProperty("line.separator"); | |
129 | PrintStream other; | |
130 | List<String> stringList = Collections.synchronizedList(new ArrayList<String>()); | |
131 | ||
132 | public StringPrintStream(PrintStream ps) { | |
133 | super(ps); | |
134 | other = ps; | |
135 | } | |
136 | ||
137 | public void print(String s) { | |
138 | other.print(s); | |
139 | stringList.add(s); | |
140 | } | |
141 | ||
142 | public void println(String s) { | |
143 | other.println(s); | |
144 | stringList.add(s); | |
145 | } | |
146 | ||
147 | public void println(Object o) { | |
148 | other.println(o); | |
149 | stringList.add(o.toString()); | |
150 | } | |
151 | }; | |
152 | ||
153 | } |
+144
-0
0 | /** | |
1 | * Copyright (c) 2004-2016 QOS.ch | |
2 | * All rights reserved. | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining | |
5 | * a copy of this software and associated documentation files (the | |
6 | * "Software"), to deal in the Software without restriction, including | |
7 | * without limitation the rights to use, copy, modify, merge, publish, | |
8 | * distribute, sublicense, and/or sell copies of the Software, and to | |
9 | * permit persons to whom the Software is furnished to do so, subject to | |
10 | * the following conditions: | |
11 | * | |
12 | * The above copyright notice and this permission notice shall be | |
13 | * included in all copies or substantial portions of the Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
16 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
17 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
18 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE | |
19 | * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION | |
20 | * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION | |
21 | * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
22 | * | |
23 | */ | |
24 | package org.slf4j.impl; | |
25 | ||
26 | import static org.junit.Assert.assertTrue; | |
27 | ||
28 | import java.io.PrintStream; | |
29 | import java.util.ArrayList; | |
30 | import java.util.Collections; | |
31 | import java.util.List; | |
32 | import java.util.Random; | |
33 | import java.util.concurrent.BrokenBarrierException; | |
34 | import java.util.concurrent.CyclicBarrier; | |
35 | import java.util.concurrent.atomic.AtomicLong; | |
36 | ||
37 | import org.junit.After; | |
38 | import org.junit.Before; | |
39 | import org.junit.Test; | |
40 | import org.slf4j.Logger; | |
41 | import org.slf4j.LoggerAccessingThread; | |
42 | import org.slf4j.LoggerFactory; | |
43 | import org.slf4j.LoggerFactoryFriend; | |
44 | ||
45 | public class SimpleLoggerMultithreadedInitializationTest { | |
46 | ||
47 | final static int THREAD_COUNT = 4 + Runtime.getRuntime().availableProcessors() * 2; | |
48 | ||
49 | private final AtomicLong eventCount = new AtomicLong(0); | |
50 | private final PrintStream oldErr = System.err; | |
51 | private final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT + 1); | |
52 | ||
53 | final int diff = new Random().nextInt(10000); | |
54 | final String loggerName = this.getClass().getName(); | |
55 | StringPrintStream sps = new StringPrintStream(oldErr, true); | |
56 | ||
57 | @Before | |
58 | public void setup() { | |
59 | System.out.println("THREAD_COUNT=" + THREAD_COUNT); | |
60 | System.setErr(sps); | |
61 | System.setProperty(SimpleLogger.LOG_FILE_KEY, "System.err"); | |
62 | LoggerFactoryFriend.reset(); | |
63 | } | |
64 | ||
65 | @After | |
66 | public void tearDown() throws Exception { | |
67 | LoggerFactoryFriend.reset(); | |
68 | System.clearProperty(SimpleLogger.LOG_FILE_KEY); | |
69 | System.setErr(oldErr); | |
70 | } | |
71 | ||
72 | @Test | |
73 | public void multiThreadedInitialization() throws InterruptedException, BrokenBarrierException { | |
74 | ||
75 | @SuppressWarnings("unused") | |
76 | LoggerAccessingThread[] accessors = harness(); | |
77 | ||
78 | Logger logger = LoggerFactory.getLogger(loggerName + diff); | |
79 | logger.info("hello"); | |
80 | eventCount.getAndIncrement(); | |
81 | ||
82 | int NUM_LINES_IN_SLF4J_REPLAY_WARNING = 3; | |
83 | ||
84 | long expected = eventCount.get() + NUM_LINES_IN_SLF4J_REPLAY_WARNING; | |
85 | int actual = sps.stringList.size(); | |
86 | assertTrue(expected + " >= " + actual, expected >= actual); | |
87 | assertTrue(expected + " < " + actual + " + 16", expected < actual + 16); | |
88 | } | |
89 | ||
90 | private LoggerAccessingThread[] harness() throws InterruptedException, BrokenBarrierException { | |
91 | final LoggerAccessingThread[] threads = new LoggerAccessingThread[THREAD_COUNT]; | |
92 | for (int i = 0; i < THREAD_COUNT; i++) { | |
93 | LoggerAccessingThread simpleLoggerThread = new LoggerAccessingThread(barrier, i, eventCount); | |
94 | threads[i] = simpleLoggerThread; | |
95 | simpleLoggerThread.start(); | |
96 | } | |
97 | ||
98 | barrier.await(); | |
99 | for (int i = 0; i < THREAD_COUNT; i++) { | |
100 | threads[i].join(); | |
101 | } | |
102 | return threads; | |
103 | } | |
104 | ||
105 | ||
106 | static class StringPrintStream extends PrintStream { | |
107 | ||
108 | public static final String LINE_SEP = System.getProperty("line.separator"); | |
109 | PrintStream other; | |
110 | boolean duplicate = false; | |
111 | ||
112 | List<String> stringList = Collections.synchronizedList(new ArrayList<String>()); | |
113 | ||
114 | public StringPrintStream(PrintStream ps, boolean duplicate) { | |
115 | super(ps); | |
116 | other = ps; | |
117 | this.duplicate = duplicate; | |
118 | } | |
119 | ||
120 | public StringPrintStream(PrintStream ps) { | |
121 | this(ps, false); | |
122 | } | |
123 | ||
124 | public void print(String s) { | |
125 | if (duplicate) | |
126 | other.print(s); | |
127 | stringList.add(s); | |
128 | } | |
129 | ||
130 | public void println(String s) { | |
131 | if (duplicate) | |
132 | other.println(s); | |
133 | stringList.add(s); | |
134 | } | |
135 | ||
136 | public void println(Object o) { | |
137 | if (duplicate) | |
138 | other.println(o); | |
139 | stringList.add(o.toString()); | |
140 | } | |
141 | }; | |
142 | ||
143 | } |