From 19e74fe5dacd03e0cb5582f840e15262e39fe24f Mon Sep 17 00:00:00 2001
From: Jiri Vanek <jvanek@redhat.com>
Date: Wed, 25 Sep 2013 18:50:18 +0200
Subject: Introduced logging bottleneck
---
.../sourceforge/jnlp/DefaultLaunchHandlerTest.java | 71 ++--
.../jnlp/cache/ResourceTrackerTest.java | 62 +++-
.../net/sourceforge/jnlp/util/HttpUtilsTest.java | 52 ++-
.../sourceforge/jnlp/util/XDesktopEntryTest.java | 4 -
.../sourceforge/jnlp/util/logging/FileLogTest.java | 178 ++++++++++
.../jnlp/util/logging/OutputControllerTest.java | 367 +++++++++++++++++++++
.../jnlp/util/logging/PrintStreamLoggerTest.java | 113 +++++++
.../testcases/XDGspecificationTests.java | 2 -
.../net/sourceforge/jnlp/ServerAccess.java | 12 +-
9 files changed, 794 insertions(+), 67 deletions(-)
create mode 100644 tests/netx/unit/net/sourceforge/jnlp/util/logging/FileLogTest.java
create mode 100644 tests/netx/unit/net/sourceforge/jnlp/util/logging/OutputControllerTest.java
create mode 100644 tests/netx/unit/net/sourceforge/jnlp/util/logging/PrintStreamLoggerTest.java
(limited to 'tests')
diff --git a/tests/netx/unit/net/sourceforge/jnlp/DefaultLaunchHandlerTest.java b/tests/netx/unit/net/sourceforge/jnlp/DefaultLaunchHandlerTest.java
index e5d1e44..7a68c74 100644
--- a/tests/netx/unit/net/sourceforge/jnlp/DefaultLaunchHandlerTest.java
+++ b/tests/netx/unit/net/sourceforge/jnlp/DefaultLaunchHandlerTest.java
@@ -42,70 +42,94 @@ import static org.junit.Assert.assertTrue;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
+import net.sourceforge.jnlp.util.logging.OutputController;
import org.junit.Test;
public class DefaultLaunchHandlerTest {
+ private static class LocalLogger extends OutputController {
+
+ private static class AccessibleStream extends PrintStream {
+
+ public AccessibleStream(ByteArrayOutputStream out) {
+ super(out);
+ }
+
+ public ByteArrayOutputStream getOut() {
+ return (ByteArrayOutputStream) out;
+ }
+ }
+
+ LocalLogger() {
+ super(new AccessibleStream(new ByteArrayOutputStream()), new AccessibleStream(new ByteArrayOutputStream()));
+ }
+
+ public String getStream1() {
+ return ((AccessibleStream) (super.getOut())).getOut().toString();
+ }
+
+ public String getStream2() {
+ return ((AccessibleStream) (super.getErr())).getOut().toString();
+ }
+ }
+
@Test
public void testBasicLaunch() {
- ByteArrayOutputStream baos = new ByteArrayOutputStream();
- DefaultLaunchHandler handler = new DefaultLaunchHandler(new PrintStream(baos));
+ LocalLogger l = new LocalLogger();
+ DefaultLaunchHandler handler = new DefaultLaunchHandler(l);
// all no-ops with no output
handler.launchInitialized(null);
handler.launchStarting(null);
handler.launchCompleted(null);
- String output = baos.toString();
- assertEquals("", output);
+ assertEquals("", l.getStream1());
+ assertEquals("", l.getStream2());
}
@Test
public void testLaunchWarning() {
- ByteArrayOutputStream baos = new ByteArrayOutputStream();
- DefaultLaunchHandler handler = new DefaultLaunchHandler(new PrintStream(baos));
+ LocalLogger l = new LocalLogger();
+ DefaultLaunchHandler handler = new DefaultLaunchHandler(l);
LaunchException warning = new LaunchException(null, null,
"severe", "warning type", "test warning", "this is a test of the warning");
boolean continueLaunch = handler.launchWarning(warning);
assertTrue(continueLaunch);
- String output = baos.toString();
- assertEquals("netx: warning type: test warning\n", output);
+ assertEquals("netx: warning type: test warning\n", l.getStream1());
}
@Test
public void testLaunchError() {
- ByteArrayOutputStream baos = new ByteArrayOutputStream();
- DefaultLaunchHandler handler = new DefaultLaunchHandler(new PrintStream(baos));
+ LocalLogger l = new LocalLogger();
+ DefaultLaunchHandler handler = new DefaultLaunchHandler(l);
LaunchException error = new LaunchException(null, null,
"severe", "error type", "test error", "this is a test of the error");
handler.launchError(error);
- String output = baos.toString();
- assertEquals("netx: error type: test error\n", output);
+ assertEquals("netx: error type: test error\n", l.getStream1());
}
@Test
public void testLaunchErrorWithCause() {
- ByteArrayOutputStream baos = new ByteArrayOutputStream();
- DefaultLaunchHandler handler = new DefaultLaunchHandler(new PrintStream(baos));
+ LocalLogger l = new LocalLogger();
+ DefaultLaunchHandler handler = new DefaultLaunchHandler(l);
ParseException parse = new ParseException("no information element");
LaunchException error = new LaunchException(null, parse,
"severe", "error type", "test error", "this is a test of the error");
handler.launchError(error);
- String output = baos.toString();
- assertEquals("netx: error type: test error (no information element)\n", output);
+ assertEquals("netx: error type: test error (no information element)\n", l.getStream1());
}
@Test
public void testLaunchErrorWithNestedCause() {
- ByteArrayOutputStream baos = new ByteArrayOutputStream();
- DefaultLaunchHandler handler = new DefaultLaunchHandler(new PrintStream(baos));
+ LocalLogger l = new LocalLogger();
+ DefaultLaunchHandler handler = new DefaultLaunchHandler(l);
ParseException parse = new ParseException("no information element");
RuntimeException runtime = new RuntimeException("programmer made a mistake", parse);
@@ -113,21 +137,18 @@ public class DefaultLaunchHandlerTest {
"severe", "error type", "test error", "this is a test of the error");
handler.launchError(error);
- String output = baos.toString();
- assertEquals("netx: error type: test error (programmer made a mistake (no information element))\n", output);
+ assertEquals("netx: error type: test error (programmer made a mistake (no information element))\n", l.getStream1());
}
-
@Test
public void testValidationError() {
- ByteArrayOutputStream baos = new ByteArrayOutputStream();
- DefaultLaunchHandler handler = new DefaultLaunchHandler(new PrintStream(baos));
+ LocalLogger l = new LocalLogger();
+ DefaultLaunchHandler handler = new DefaultLaunchHandler(l);
LaunchException error = new LaunchException(null, null,
"severe", "validation-error type", "test validation-error", "this is a test of a validation error");
handler.validationError(error);
- String output = baos.toString();
- assertEquals("netx: validation-error type: test validation-error\n", output);
+ assertEquals("netx: validation-error type: test validation-error\n", l.getStream1());
}
}
diff --git a/tests/netx/unit/net/sourceforge/jnlp/cache/ResourceTrackerTest.java b/tests/netx/unit/net/sourceforge/jnlp/cache/ResourceTrackerTest.java
index 03d942b..b4c0079 100644
--- a/tests/netx/unit/net/sourceforge/jnlp/cache/ResourceTrackerTest.java
+++ b/tests/netx/unit/net/sourceforge/jnlp/cache/ResourceTrackerTest.java
@@ -41,6 +41,7 @@ import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Method;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
@@ -50,6 +51,7 @@ import net.sourceforge.jnlp.ServerAccess;
import net.sourceforge.jnlp.ServerLauncher;
import net.sourceforge.jnlp.Version;
import net.sourceforge.jnlp.runtime.JNLPRuntime;
+import net.sourceforge.jnlp.util.logging.OutputController;
import net.sourceforge.jnlp.util.UrlUtils;
import org.junit.AfterClass;
import org.junit.Assert;
@@ -60,7 +62,7 @@ public class ResourceTrackerTest {
public static ServerLauncher testServer;
public static ServerLauncher testServerWithBrokenHead;
- private static PrintStream backedUpStream;
+ private static PrintStream[] backedUpStream = new PrintStream[4];
private static ByteArrayOutputStream currentErrorStream;
private static final String nameStub1 = "itw-server";
private static final String nameStub2 = "test-file";
@@ -112,21 +114,47 @@ public class ResourceTrackerTest {
return n;
}
-
+
@BeforeClass
- public static void redirectErr() {
- if (backedUpStream == null) {
- backedUpStream = System.err;
+ //keeping silent outputs from launched jvm
+ public static void redirectErr() throws IOException {
+ for (int i = 0; i < backedUpStream.length; i++) {
+ if (backedUpStream[i] == null) {
+ switch (i) {
+ case 0:
+ backedUpStream[i] = System.out;
+ break;
+ case 1:
+ backedUpStream[i] = System.err;
+ break;
+ case 2:
+ backedUpStream[i] = OutputController.getLogger().getOut();
+ break;
+ case 3:
+ backedUpStream[i] = OutputController.getLogger().getErr();
+ break;
+ }
+
+ }
+
}
currentErrorStream = new ByteArrayOutputStream();
+ System.setOut(new PrintStream(currentErrorStream));
System.setErr(new PrintStream(currentErrorStream));
+ OutputController.getLogger().setOut(new PrintStream(currentErrorStream));
+ OutputController.getLogger().setErr(new PrintStream(currentErrorStream));
+
}
@AfterClass
- public static void redirectErrBack() throws UnsupportedEncodingException {
+ public static void redirectErrBack() throws IOException {
ServerAccess.logErrorReprint(currentErrorStream.toString("utf-8"));
- System.setErr(backedUpStream);
+ System.setOut(backedUpStream[0]);
+ System.setErr(backedUpStream[1]);
+ OutputController.getLogger().setOut(backedUpStream[2]);
+ OutputController.getLogger().setErr(backedUpStream[3]);
+
}
@@ -141,14 +169,18 @@ public class ResourceTrackerTest {
}
@BeforeClass
- public static void startServer() throws IOException {
+ public static void startServer() throws Exception {
+ redirectErr();
testServer = ServerAccess.getIndependentInstance(System.getProperty("java.io.tmpdir"), ServerAccess.findFreePort());
+ redirectErrBack();
}
@BeforeClass
- public static void startServer2() throws IOException {
+ public static void startServer2() throws Exception {
+ redirectErr();
testServerWithBrokenHead = ServerAccess.getIndependentInstance(System.getProperty("java.io.tmpdir"), ServerAccess.findFreePort());
testServerWithBrokenHead.setSupportingHeadRequest(false);
+ redirectErrBack();
}
@AfterClass
@@ -162,7 +194,7 @@ public class ResourceTrackerTest {
}
@Test
- public void getUrlResponseCodeTestWorkingHeadRequest() throws IOException {
+ public void getUrlResponseCodeTestWorkingHeadRequest() throws Exception {
redirectErr();
try {
File f = File.createTempFile(nameStub1, nameStub2);
@@ -177,7 +209,7 @@ public class ResourceTrackerTest {
}
@Test
- public void getUrlResponseCodeTestNotWorkingHeadRequest() throws IOException {
+ public void getUrlResponseCodeTestNotWorkingHeadRequest() throws Exception {
redirectErr();
try {
File f = File.createTempFile(nameStub1, nameStub2);
@@ -192,7 +224,7 @@ public class ResourceTrackerTest {
}
@Test
- public void getUrlResponseCodeTestGetRequestOnNotWorkingHeadRequest() throws IOException {
+ public void getUrlResponseCodeTestGetRequestOnNotWorkingHeadRequest() throws Exception {
redirectErr();
try {
File f = File.createTempFile(nameStub1, nameStub2);
@@ -207,7 +239,7 @@ public class ResourceTrackerTest {
}
@Test
- public void getUrlResponseCodeTestGetRequest() throws IOException {
+ public void getUrlResponseCodeTestGetRequest() throws Exception {
redirectErr();
try {
File f = File.createTempFile(nameStub1, nameStub2);
@@ -222,7 +254,7 @@ public class ResourceTrackerTest {
}
@Test
- public void getUrlResponseCodeTestWrongRequest() throws IOException {
+ public void getUrlResponseCodeTestWrongRequest() throws Exception {
redirectErr();
try {
File f = File.createTempFile(nameStub1, nameStub2);
@@ -248,7 +280,7 @@ public class ResourceTrackerTest {
}
@Test
- public void findBestUrltest() throws IOException {
+ public void findBestUrltest() throws Exception {
redirectErr();
try {
File fileForServerWithHeader = File.createTempFile(nameStub1, nameStub2);
diff --git a/tests/netx/unit/net/sourceforge/jnlp/util/HttpUtilsTest.java b/tests/netx/unit/net/sourceforge/jnlp/util/HttpUtilsTest.java
index 08a6060..c585eed 100644
--- a/tests/netx/unit/net/sourceforge/jnlp/util/HttpUtilsTest.java
+++ b/tests/netx/unit/net/sourceforge/jnlp/util/HttpUtilsTest.java
@@ -44,27 +44,57 @@ import java.net.HttpURLConnection;
import java.net.URL;
import net.sourceforge.jnlp.ServerAccess;
import net.sourceforge.jnlp.ServerLauncher;
+import net.sourceforge.jnlp.util.logging.OutputController;
+import org.junit.AfterClass;
import org.junit.Assert;
+import org.junit.BeforeClass;
import org.junit.Test;
public class HttpUtilsTest {
- private static PrintStream backedUpStream;
- private static ByteArrayOutputStream nwErrorStream;
+ private static PrintStream[] backedUpStream = new PrintStream[4];
+ private static ByteArrayOutputStream currentErrorStream;
- public static void redirectErr() {
- if (backedUpStream == null) {
- backedUpStream = System.err;
+ @BeforeClass
+ //keeping silent outputs from launched jvm
+ public static void redirectErr() throws IOException {
+ for (int i = 0; i < backedUpStream.length; i++) {
+ if (backedUpStream[i] == null) {
+ switch (i) {
+ case 0:
+ backedUpStream[i] = System.out;
+ break;
+ case 1:
+ backedUpStream[i] = System.err;
+ break;
+ case 2:
+ backedUpStream[i] = OutputController.getLogger().getOut();
+ break;
+ case 3:
+ backedUpStream[i] = OutputController.getLogger().getErr();
+ break;
+ }
+
+ }
+
}
- nwErrorStream = new ByteArrayOutputStream();
- System.setErr(new PrintStream(nwErrorStream));
+ currentErrorStream = new ByteArrayOutputStream();
+ System.setOut(new PrintStream(currentErrorStream));
+ System.setErr(new PrintStream(currentErrorStream));
+ OutputController.getLogger().setOut(new PrintStream(currentErrorStream));
+ OutputController.getLogger().setErr(new PrintStream(currentErrorStream));
+
}
-
- public static void redirectErrBack() throws UnsupportedEncodingException {
- ServerAccess.logErrorReprint(nwErrorStream.toString("utf-8"));
- System.setErr(backedUpStream);
+ @AfterClass
+ public static void redirectErrBack() throws IOException {
+ ServerAccess.logErrorReprint(currentErrorStream.toString("utf-8"));
+ System.setOut(backedUpStream[0]);
+ System.setErr(backedUpStream[1]);
+ OutputController.getLogger().setOut(backedUpStream[2]);
+ OutputController.getLogger().setErr(backedUpStream[3]);
+
}
diff --git a/tests/netx/unit/net/sourceforge/jnlp/util/XDesktopEntryTest.java b/tests/netx/unit/net/sourceforge/jnlp/util/XDesktopEntryTest.java
index 1cd343c..8985085 100644
--- a/tests/netx/unit/net/sourceforge/jnlp/util/XDesktopEntryTest.java
+++ b/tests/netx/unit/net/sourceforge/jnlp/util/XDesktopEntryTest.java
@@ -41,11 +41,7 @@ import java.io.IOException;
import java.io.StringReader;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
import java.util.Set;
import net.sourceforge.jnlp.ServerAccess;
diff --git a/tests/netx/unit/net/sourceforge/jnlp/util/logging/FileLogTest.java b/tests/netx/unit/net/sourceforge/jnlp/util/logging/FileLogTest.java
new file mode 100644
index 0000000..ed16780
--- /dev/null
+++ b/tests/netx/unit/net/sourceforge/jnlp/util/logging/FileLogTest.java
@@ -0,0 +1,178 @@
+/*Copyright (C) 2013 Red Hat, Inc.
+
+ This file is part of IcedTea.
+
+ IcedTea is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, version 2.
+
+ IcedTea is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with IcedTea; see the file COPYING. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301 USA.
+
+ Linking this library statically or dynamically with other modules is
+ making a combined work based on this library. Thus, the terms and
+ conditions of the GNU General Public License cover the whole
+ combination.
+
+ As a special exception, the copyright holders of this library give you
+ permission to link this library with independent modules to produce an
+ executable, regardless of the license terms of these independent
+ modules, and to copy and distribute the resulting executable under
+ terms of your choice, provided that you also meet, for each linked
+ independent module, the terms and conditions of the license of that
+ module. An independent module is a module which is not derived from
+ or based on this library. If you modify this library, you may extend
+ this exception to your version of the library, but you are not
+ obligated to do so. If you do not wish to do so, delete this
+ exception statement from your version.
+ */
+package net.sourceforge.jnlp.util.logging;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import net.sourceforge.jnlp.closinglisteners.RulesFolowingClosingListener;
+import net.sourceforge.jnlp.util.StreamUtils;
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class FileLogTest {
+
+ private static File[] loggingTargets = new File[12];
+ private static String line1 = "I'm logged line one";
+ private static String line2 = "I'm logged line two";
+ private static String line3 = "I'm logged line three";
+ private static RulesFolowingClosingListener.ContainsRule r1 = new RulesFolowingClosingListener.ContainsRule(line1);
+ private static RulesFolowingClosingListener.ContainsRule r2 = new RulesFolowingClosingListener.ContainsRule(line2);
+ private static RulesFolowingClosingListener.ContainsRule r3 = new RulesFolowingClosingListener.ContainsRule(line3);
+
+ @BeforeClass
+ public static void prepareTmpFiles() throws IOException {
+ for (int i = 0; i < loggingTargets.length; i++) {
+ loggingTargets[i] = File.createTempFile("fileLogger", "iteTest");
+ loggingTargets[i].deleteOnExit();
+ }
+ //delete first half of the files, logger should handle both casses
+ for (int i = 0; i < loggingTargets.length / 2; i++) {
+ loggingTargets[i].delete();
+ }
+
+ }
+
+ @AfterClass
+ public static void cleanTmpFiles() throws IOException {
+ for (int i = 0; i < loggingTargets.length; i++) {
+ loggingTargets[i].delete();
+ }
+ }
+
+ @Test
+ public void isAppendingLoggerLoggingOnNotExisitngFile() throws Exception {
+ int i = 0;
+ FileLog l = new FileLog(loggingTargets[i].getAbsolutePath(), true);
+ l.log(line1);
+ String s = StreamUtils.readStreamAsString(new FileInputStream(loggingTargets[i]), true);
+ Assert.assertTrue(r1.evaluate(s));
+ }
+
+ @Test
+ public void isRewritingLoggerLoggingOnNotExisitngFile() throws Exception {
+ int i = 1;
+ FileLog l = new FileLog(loggingTargets[i].getAbsolutePath(), false);
+ l.log(line1);
+ String s = StreamUtils.readStreamAsString(new FileInputStream(loggingTargets[i]), true);
+ Assert.assertTrue(r1.evaluate(s));
+ }
+
+ @Test
+ public void isRewritingLoggerRewritingOnNotExisitngFile() throws Exception {
+ int i = 2;
+ FileLog l1 = new FileLog(loggingTargets[i].getAbsolutePath(), false);
+ l1.log(line2);
+ String s1 = StreamUtils.readStreamAsString(new FileInputStream(loggingTargets[i]), true);
+ Assert.assertTrue(r2.evaluate(s1));
+ l1.close();
+ FileLog l2 = new FileLog(loggingTargets[i].getAbsolutePath(), false);
+ l2.log(line3);
+ String s2 = StreamUtils.readStreamAsString(new FileInputStream(loggingTargets[i]), true);
+ Assert.assertFalse(r2.evaluate(s2));
+ Assert.assertTrue(r3.evaluate(s2));
+
+ }
+
+ @Test
+ public void isAppendingLoggerAppendingOnNotExisitngFile() throws Exception {
+ int i = 4;
+ FileLog l1 = new FileLog(loggingTargets[i].getAbsolutePath(), true);
+ l1.log(line2);
+ String s1 = StreamUtils.readStreamAsString(new FileInputStream(loggingTargets[i]), true);
+ Assert.assertTrue(r2.evaluate(s1));
+ l1.close();
+ FileLog l2 = new FileLog(loggingTargets[i].getAbsolutePath(), true);
+ l2.log(line3);
+ String s2 = StreamUtils.readStreamAsString(new FileInputStream(loggingTargets[i]), true);
+ Assert.assertTrue(r2.evaluate(s2));
+ Assert.assertTrue(r3.evaluate(s2));
+
+ }
+
+ //************
+ @Test
+ public void isAppendingLoggerLoggingOnExisitngFile() throws Exception {
+ int i = 6;
+ FileLog l = new FileLog(loggingTargets[i].getAbsolutePath(), true);
+ l.log(line1);
+ String s = StreamUtils.readStreamAsString(new FileInputStream(loggingTargets[i]), true);
+ Assert.assertTrue(r1.evaluate(s));
+ }
+
+ @Test
+ public void isRewritingLoggerLoggingOnExisitngFile() throws Exception {
+ int i = 7;
+ FileLog l = new FileLog(loggingTargets[i].getAbsolutePath(), false);
+ l.log(line1);
+ String s = StreamUtils.readStreamAsString(new FileInputStream(loggingTargets[i]), true);
+ Assert.assertTrue(r1.evaluate(s));
+ }
+
+ @Test
+ public void isRewritingLoggerRewritingOnExisitngFile() throws Exception {
+ int i = 8;
+ FileLog l1 = new FileLog(loggingTargets[i].getAbsolutePath(), false);
+ l1.log(line2);
+ String s1 = StreamUtils.readStreamAsString(new FileInputStream(loggingTargets[i]), true);
+ Assert.assertTrue(r2.evaluate(s1));
+ l1.close();
+ FileLog l2 = new FileLog(loggingTargets[i].getAbsolutePath(), false);
+ l2.log(line3);
+ String s2 = StreamUtils.readStreamAsString(new FileInputStream(loggingTargets[i]), true);
+ Assert.assertFalse(r2.evaluate(s2));
+ Assert.assertTrue(r3.evaluate(s2));
+
+ }
+
+ @Test
+ public void isAppendingLoggerAppendingOnExisitngFile() throws Exception {
+ int i = 10;
+ FileLog l1 = new FileLog(loggingTargets[i].getAbsolutePath(), true);
+ l1.log(line2);
+ String s1 = StreamUtils.readStreamAsString(new FileInputStream(loggingTargets[i]), true);
+ Assert.assertTrue(r2.evaluate(s1));
+ l1.close();
+ FileLog l2 = new FileLog(loggingTargets[i].getAbsolutePath(), true);
+ l2.log(line3);
+ String s2 = StreamUtils.readStreamAsString(new FileInputStream(loggingTargets[i]), true);
+ Assert.assertTrue(r2.evaluate(s2));
+ Assert.assertTrue(r3.evaluate(s2));
+
+ }
+}
diff --git a/tests/netx/unit/net/sourceforge/jnlp/util/logging/OutputControllerTest.java b/tests/netx/unit/net/sourceforge/jnlp/util/logging/OutputControllerTest.java
new file mode 100644
index 0000000..8c08f45
--- /dev/null
+++ b/tests/netx/unit/net/sourceforge/jnlp/util/logging/OutputControllerTest.java
@@ -0,0 +1,367 @@
+/*Copyright (C) 2013 Red Hat, Inc.
+
+ This file is part of IcedTea.
+
+ IcedTea is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, version 2.
+
+ IcedTea is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with IcedTea; see the file COPYING. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301 USA.
+
+ Linking this library statically or dynamically with other modules is
+ making a combined work based on this library. Thus, the terms and
+ conditions of the GNU General Public License cover the whole
+ combination.
+
+ As a special exception, the copyright holders of this library give you
+ permission to link this library with independent modules to produce an
+ executable, regardless of the license terms of these independent
+ modules, and to copy and distribute the resulting executable under
+ terms of your choice, provided that you also meet, for each linked
+ independent module, the terms and conditions of the license of that
+ module. An independent module is a module which is not derived from
+ or based on this library. If you modify this library, you may extend
+ this exception to your version of the library, but you are not
+ obligated to do so. If you do not wish to do so, delete this
+ exception statement from your version.
+ */
+package net.sourceforge.jnlp.util.logging;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.PrintStream;
+import java.util.Random;
+import net.sourceforge.jnlp.closinglisteners.RulesFolowingClosingListener;
+import net.sourceforge.jnlp.util.StreamUtils;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class OutputControllerTest {
+
+ private static String line1 = "I'm logged line one";
+ private static String line2 = "I'm logged line two";
+ private static String line3 = "I'm logged line three";
+ private static String line4 = "I'm logged line four";
+ private static String line5 = "I'm logged line five";
+ private static String line6 = "I'm logged line six";
+ private static RulesFolowingClosingListener.ContainsRule r1 = new RulesFolowingClosingListener.ContainsRule(line1);
+ private static RulesFolowingClosingListener.ContainsRule r2 = new RulesFolowingClosingListener.ContainsRule(line2);
+ private static RulesFolowingClosingListener.ContainsRule r3 = new RulesFolowingClosingListener.ContainsRule(line3);
+ private static RulesFolowingClosingListener.ContainsRule r4 = new RulesFolowingClosingListener.ContainsRule(line4);
+ private static RulesFolowingClosingListener.ContainsRule r5 = new RulesFolowingClosingListener.ContainsRule(line5);
+ private static RulesFolowingClosingListener.ContainsRule r6 = new RulesFolowingClosingListener.ContainsRule(line6);
+
+ private static class AccessiblePrintStream extends PrintStream {
+
+ public AccessiblePrintStream(ByteArrayOutputStream out) {
+ super(out);
+ }
+
+ public ByteArrayOutputStream getOut() {
+ return (ByteArrayOutputStream) out;
+ }
+ }
+
+ @Test
+ public void isLoggingStdStreams() throws Exception {
+ ByteArrayOutputStream os1 = new ByteArrayOutputStream();
+ ByteArrayOutputStream os2 = new ByteArrayOutputStream();
+ OutputController oc = new OutputController(new PrintStream(os1), new PrintStream(os2));
+ LogConfig.getLogConfig().setEnableLogging(false);
+ LogConfig.getLogConfig().setLogToFile(false);
+ LogConfig.getLogConfig().setLogToStreams(true);
+ LogConfig.getLogConfig().setLogToSysLog(false);
+ oc.log(OutputController.Level.MESSAGE_DEBUG, line1);
+ oc.log(OutputController.Level.ERROR_DEBUG, line1);
+ oc.flush();
+ Assert.assertFalse(r1.evaluate(os1.toString("utf-8")));
+ Assert.assertFalse(r1.evaluate(os2.toString("utf-8")));
+ oc.log(OutputController.Level.MESSAGE_ALL, line1);
+ oc.log(OutputController.Level.ERROR_DEBUG, line1);
+ oc.flush();
+ Assert.assertTrue(r1.evaluate(os1.toString("utf-8")));
+ Assert.assertFalse(r1.evaluate(os2.toString("utf-8")));
+ oc.log(OutputController.Level.ERROR_ALL, line1);
+ oc.flush();
+ Assert.assertTrue(r1.evaluate(os2.toString("utf-8")));
+
+ LogConfig.getLogConfig().setEnableLogging(true);
+ oc.log(OutputController.Level.MESSAGE_DEBUG, line2);
+ oc.flush();
+ Assert.assertTrue(r2.evaluate(os1.toString("utf-8")));
+ Assert.assertFalse(r2.evaluate(os2.toString("utf-8")));
+ oc.log(OutputController.Level.ERROR_DEBUG, line2);
+ oc.flush();
+ Assert.assertTrue(r2.evaluate(os1.toString("utf-8")));
+ Assert.assertTrue(r2.evaluate(os2.toString("utf-8")));
+
+ oc.log(OutputController.Level.ERROR_DEBUG, line3);
+ oc.flush();
+ Assert.assertFalse(r3.evaluate(os1.toString("utf-8")));
+ Assert.assertTrue(r3.evaluate(os2.toString("utf-8")));
+ oc.log(OutputController.Level.MESSAGE_DEBUG, line3);
+ oc.flush();
+ Assert.assertTrue(r3.evaluate(os1.toString("utf-8")));
+ Assert.assertTrue(r3.evaluate(os2.toString("utf-8")));
+
+ LogConfig.getLogConfig().setEnableLogging(false);
+ oc.log(OutputController.Level.WARNING_DEBUG, line4);
+ oc.flush();
+ Assert.assertFalse(r4.evaluate(os1.toString("utf-8")));
+ Assert.assertFalse(r4.evaluate(os2.toString("utf-8")));
+ oc.log(OutputController.Level.WARNING_ALL, line5);
+ oc.flush();
+ Assert.assertTrue(r5.evaluate(os1.toString("utf-8")));
+ Assert.assertTrue(r5.evaluate(os2.toString("utf-8")));
+ LogConfig.getLogConfig().setEnableLogging(true);
+ oc.log(OutputController.Level.WARNING_DEBUG, line4);
+ oc.flush();
+ Assert.assertTrue(r4.evaluate(os1.toString("utf-8")));
+ Assert.assertTrue(r4.evaluate(os2.toString("utf-8")));
+
+ }
+ private static final Random random = new Random();
+ private int delayable = 0;
+
+ private class IdedRunnable implements Runnable {
+
+ private final int id;
+ private final OutputController oc;
+ private boolean done = false;
+ private final int iterations;
+
+ public IdedRunnable(int id, OutputController oc, int iterations) {
+ this.id = id;
+ this.oc = oc;
+ this.iterations = iterations;
+ }
+
+ @Override
+ public void run() {
+ for (int i = 0; i < iterations; i++) {
+ try {
+ //be sure this pattern is kept in assers
+ oc.log(OutputController.Level.WARNING_ALL, "thread " + id + " line " + i);
+ Thread.sleep(random.nextInt(delayable));
+ } catch (Exception ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+ done = true;
+ }
+
+ public boolean isDone() {
+ return done;
+ }
+ }
+
+ /**
+ * todo - include syslog once implemented
+ */
+ @Test
+ public void isParalelLogingWorking() throws Exception {
+ LogConfig.getLogConfig().setEnableLogging(true);
+ LogConfig.getLogConfig().setLogToStreams(true);
+ LogConfig.getLogConfig().setLogToSysLog(false);
+ String s = "";
+ //this was tested with 1-100 iterations and 100 threads. But can couse OutOfMemoryError
+ int maxi = 90;
+ int minits = 70;
+ int maxt = 10;
+ //tested with delayable 1-10, but took minutes then
+ for (delayable = 1; delayable < 1; delayable++) {
+ for (int iterations = minits; iterations < maxi; iterations++) {
+ for (int threads = 1; threads < maxt; threads++) {
+ LogConfig.getLogConfig().setLogToFile(false);
+ System.gc();
+ ByteArrayOutputStream os1 = new ByteArrayOutputStream();
+ ByteArrayOutputStream os2 = new ByteArrayOutputStream();
+ OutputController oc = new OutputController(new PrintStream(os1), new PrintStream(os2));
+
+ File f = File.createTempFile("replacedFilelogger", "itwTest");
+ f.deleteOnExit();
+ oc.setFileLog(new FileLog(f.getAbsolutePath(), false));
+ LogConfig.getLogConfig().setLogToFile(true);
+
+ ThreadGroup tg = new ThreadGroup("TerribleGroup");
+ IdedRunnable[] idedRunnables = new IdedRunnable[threads];
+ Thread[] xt = new Thread[threads];
+ for (int i = 0; i < threads; i++) {
+ Thread.sleep(random.nextInt(delayable));
+ idedRunnables[i] = new IdedRunnable(i, oc, iterations);
+ xt[i] = new Thread(tg, idedRunnables[i], "iterations = " + iterations + "; threads = " + threads + "; delayable = " + delayable);
+ xt[i].start();
+ }
+ while (true) {
+ boolean ok = true;
+ for (IdedRunnable idedRunnable : idedRunnables) {
+ if (!idedRunnable.isDone()) {
+ ok = false;
+ break;
+ }
+ }
+ if (ok) {
+ break;
+ }
+ }
+ oc.flush();
+ String s1 = os1.toString("utf-8");
+ String s2 = os2.toString("utf-8");
+ String s3 = StreamUtils.readStreamAsString(new FileInputStream(f), true);
+ for (int i = minits; i < maxi; i++) {
+ for (int t = 0; t < maxt; t++) {
+ //be sure this pattern is kept in IdedRunnable
+ String expected = "thread " + t + " line " + i;
+ if (i >= iterations || t >= threads) {
+ Assert.assertFalse(s1.contains(expected));
+ Assert.assertFalse(s2.contains(expected));
+ Assert.assertFalse(s3.contains(expected));
+ } else {
+ Assert.assertTrue(s1.contains(expected));
+ Assert.assertTrue(s2.contains(expected));
+ Assert.assertTrue(s3.contains(expected));
+ }
+
+ }
+ }
+ tg.destroy();
+
+ }
+ }
+ }
+
+
+
+ }
+
+ @Test
+ public void isChangingOfStreasmWorking() throws Exception {
+ LogConfig.getLogConfig().setEnableLogging(true);
+ LogConfig.getLogConfig().setLogToFile(false);
+ LogConfig.getLogConfig().setLogToStreams(true);
+ LogConfig.getLogConfig().setLogToSysLog(false);
+ ByteArrayOutputStream os1 = new ByteArrayOutputStream();
+ ByteArrayOutputStream os2 = new ByteArrayOutputStream();
+ OutputController oc = new OutputController(new PrintStream(os1), new PrintStream(os2));
+ oc.log(OutputController.Level.MESSAGE_ALL, line1);
+ oc.log(OutputController.Level.ERROR_ALL, line1);
+ oc.flush();
+ ByteArrayOutputStream os3 = new ByteArrayOutputStream();
+ ByteArrayOutputStream os4 = new ByteArrayOutputStream();
+ oc.setOut(new PrintStream(os3));
+ oc.log(OutputController.Level.MESSAGE_ALL, line2);
+ oc.log(OutputController.Level.ERROR_ALL, line2);
+ oc.flush();
+ oc.setErr(new PrintStream(os4));
+ oc.log(OutputController.Level.MESSAGE_ALL, line3);
+ oc.log(OutputController.Level.ERROR_ALL, line3);
+ oc.flush();
+
+ Assert.assertTrue(r1.evaluate(os1.toString("utf-8")));
+ Assert.assertTrue(r1.evaluate(os2.toString("utf-8")));
+ Assert.assertFalse(r1.evaluate(os3.toString("utf-8")));
+ Assert.assertFalse(r1.evaluate(os4.toString("utf-8")));
+
+
+ Assert.assertFalse(r2.evaluate(os1.toString("utf-8")));
+ Assert.assertTrue(r2.evaluate(os2.toString("utf-8")));
+ Assert.assertTrue(r2.evaluate(os3.toString("utf-8")));
+ Assert.assertFalse(r2.evaluate(os4.toString("utf-8")));
+
+ Assert.assertFalse(r3.evaluate(os1.toString("utf-8")));
+ Assert.assertFalse(r3.evaluate(os2.toString("utf-8")));
+ Assert.assertTrue(r3.evaluate(os3.toString("utf-8")));
+ Assert.assertTrue(r3.evaluate(os4.toString("utf-8")));
+
+ LogConfig.getLogConfig().setLogToStreams(false);
+
+ oc.log(OutputController.Level.MESSAGE_ALL, line4);
+ oc.log(OutputController.Level.ERROR_ALL, line4);
+
+ Assert.assertFalse(r4.evaluate(os1.toString("utf-8")));
+ Assert.assertFalse(r4.evaluate(os2.toString("utf-8")));
+ Assert.assertFalse(r4.evaluate(os3.toString("utf-8")));
+ Assert.assertFalse(r4.evaluate(os4.toString("utf-8")));
+
+ }
+
+ @Test
+ public void isFileLoggerWorking() throws Exception {
+ String s1 = "";
+ String s2 = "";
+ LogConfig.getLogConfig().setEnableLogging(true);
+ LogConfig.getLogConfig().setLogToFile(false);
+ LogConfig.getLogConfig().setLogToStreams(false);
+ LogConfig.getLogConfig().setLogToSysLog(false);
+
+ ByteArrayOutputStream os1 = new ByteArrayOutputStream();
+ ByteArrayOutputStream os2 = new ByteArrayOutputStream();
+ OutputController oc = new OutputController(new PrintStream(os1), new PrintStream(os2));
+ File f1 = File.createTempFile("replacedFilelogger", "itwTest");
+ File f2 = File.createTempFile("replacedFilelogger", "itwTest");
+ f1.deleteOnExit();
+ f2.deleteOnExit();
+ oc.setFileLog(new FileLog(f1.getAbsolutePath(), false));
+ LogConfig.getLogConfig().setLogToFile(true);
+ oc.log(OutputController.Level.MESSAGE_ALL, line1);
+ oc.log(OutputController.Level.ERROR_ALL, line2);
+ oc.log(OutputController.Level.MESSAGE_ALL, line3);
+ oc.flush();
+ s1 = StreamUtils.readStreamAsString(new FileInputStream(f1), true);
+ s2 = StreamUtils.readStreamAsString(new FileInputStream(f2), true);
+
+ Assert.assertTrue(r1.evaluate(s1));
+ Assert.assertFalse(r1.evaluate(s2));
+ Assert.assertTrue(r2.evaluate(s1));
+ Assert.assertFalse(r2.evaluate(s2));
+ Assert.assertTrue(r3.evaluate(s1));
+ Assert.assertFalse(r3.evaluate(s2));
+
+ oc.setFileLog(new FileLog(f2.getAbsolutePath(), false));
+ oc.log(OutputController.Level.ERROR_ALL, line5);
+ oc.log(OutputController.Level.MESSAGE_ALL, line5);
+ oc.flush();
+
+ s1 = StreamUtils.readStreamAsString(new FileInputStream(f1), true);
+ s2 = StreamUtils.readStreamAsString(new FileInputStream(f2), true);
+
+ Assert.assertTrue(r1.evaluate(s1));
+ Assert.assertFalse(r1.evaluate(s2));
+ Assert.assertTrue(r2.evaluate(s1));
+ Assert.assertFalse(r2.evaluate(s2));
+ Assert.assertTrue(r3.evaluate(s1));
+ Assert.assertFalse(r3.evaluate(s2));
+
+ Assert.assertFalse(r5.evaluate(s1));
+ Assert.assertTrue(r5.evaluate(s2));
+
+ LogConfig.getLogConfig().setLogToFile(false);
+ oc.log(OutputController.Level.ERROR_ALL, line6);
+ oc.log(OutputController.Level.MESSAGE_ALL, line6);
+ oc.flush();
+
+ s1 = StreamUtils.readStreamAsString(new FileInputStream(f1), true);
+ s2 = StreamUtils.readStreamAsString(new FileInputStream(f2), true);
+
+ Assert.assertFalse(r6.evaluate(s1));
+ Assert.assertFalse(r6.evaluate(s2));
+
+
+ }
+
+ /**
+ * add syslog once implemented
+ */
+ @Test
+ public void isSysLoggerWorking() throws Exception {
+ }
+}
diff --git a/tests/netx/unit/net/sourceforge/jnlp/util/logging/PrintStreamLoggerTest.java b/tests/netx/unit/net/sourceforge/jnlp/util/logging/PrintStreamLoggerTest.java
new file mode 100644
index 0000000..f56099c
--- /dev/null
+++ b/tests/netx/unit/net/sourceforge/jnlp/util/logging/PrintStreamLoggerTest.java
@@ -0,0 +1,113 @@
+/*Copyright (C) 2013 Red Hat, Inc.
+
+ This file is part of IcedTea.
+
+ IcedTea is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, version 2.
+
+ IcedTea is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with IcedTea; see the file COPYING. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301 USA.
+
+ Linking this library statically or dynamically with other modules is
+ making a combined work based on this library. Thus, the terms and
+ conditions of the GNU General Public License cover the whole
+ combination.
+
+ As a special exception, the copyright holders of this library give you
+ permission to link this library with independent modules to produce an
+ executable, regardless of the license terms of these independent
+ modules, and to copy and distribute the resulting executable under
+ terms of your choice, provided that you also meet, for each linked
+ independent module, the terms and conditions of the license of that
+ module. An independent module is a module which is not derived from
+ or based on this library. If you modify this library, you may extend
+ this exception to your version of the library, but you are not
+ obligated to do so. If you do not wish to do so, delete this
+ exception statement from your version.
+ */
+package net.sourceforge.jnlp.util.logging;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import net.sourceforge.jnlp.closinglisteners.RulesFolowingClosingListener;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class PrintStreamLoggerTest {
+
+ private static String line1 = "I'm logged line one";
+ private static String line2 = "I'm logged line two";
+ private static RulesFolowingClosingListener.ContainsRule r1 = new RulesFolowingClosingListener.ContainsRule(line1);
+ private static RulesFolowingClosingListener.ContainsRule r2 = new RulesFolowingClosingListener.ContainsRule(line2);
+
+ private static class AccessiblePrintStream extends PrintStream{
+
+ public AccessiblePrintStream(ByteArrayOutputStream out) {
+ super(out);
+ }
+
+
+
+ public ByteArrayOutputStream getOut() {
+ return (ByteArrayOutputStream) out;
+ }
+ }
+
+ @Test
+ public void isLoggingAtAll() throws Exception {
+ int i = 0;
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ PrintStreamLogger l = new PrintStreamLogger(new PrintStream(output));
+ l.log(line1);
+ Assert.assertTrue(r1.evaluate(output.toString("utf-8")));
+ l.log(line2);
+ Assert.assertTrue(r1.evaluate(output.toString("utf-8")));
+ Assert.assertTrue(r2.evaluate(output.toString("utf-8")));
+ }
+
+ @Test
+ public void isReturningStream() throws Exception {
+ int i = 0;
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ AccessiblePrintStream ps = new AccessiblePrintStream(output);
+ PrintStreamLogger l = new PrintStreamLogger(ps);
+ l.log(line1);
+ Assert.assertTrue(r1.evaluate(output.toString("utf-8")));
+ AccessiblePrintStream got = (AccessiblePrintStream) l.getStream();
+ Assert.assertTrue(r1.evaluate(got.getOut().toString("utf-8")));
+ l.log(line2);
+ Assert.assertTrue(r1.evaluate(output.toString("utf-8")));
+ Assert.assertTrue(r2.evaluate(output.toString("utf-8")));
+ Assert.assertTrue(r1.evaluate(got.getOut().toString("utf-8")));
+ Assert.assertTrue(r2.evaluate(got.getOut().toString("utf-8")));
+ Assert.assertTrue(got == ps);
+ }
+
+ @Test
+ public void isSettingStream() throws Exception {
+ int i = 0;
+ ByteArrayOutputStream output1 = new ByteArrayOutputStream();
+ ByteArrayOutputStream output2 = new ByteArrayOutputStream();
+ AccessiblePrintStream ps = new AccessiblePrintStream(output1);
+ PrintStreamLogger l = new PrintStreamLogger(ps);
+ l.log(line1);
+ Assert.assertTrue(r1.evaluate(output1.toString("utf-8")));
+ AccessiblePrintStream set = new AccessiblePrintStream(output2);
+ l.setStream(set);
+ l.log(line2);
+ Assert.assertFalse(r1.evaluate(output2.toString("utf-8")));
+ Assert.assertTrue(r2.evaluate(output2.toString("utf-8")));
+ Assert.assertFalse(r1.evaluate(set.getOut().toString("utf-8")));
+ Assert.assertTrue(r2.evaluate(set.getOut().toString("utf-8")));
+ Assert.assertTrue(set != ps);
+ Assert.assertTrue(set == l.getStream());
+ }
+}
diff --git a/tests/reproducers/simple/simpletest1/testcases/XDGspecificationTests.java b/tests/reproducers/simple/simpletest1/testcases/XDGspecificationTests.java
index 7bfc58a..176d417 100644
--- a/tests/reproducers/simple/simpletest1/testcases/XDGspecificationTests.java
+++ b/tests/reproducers/simple/simpletest1/testcases/XDGspecificationTests.java
@@ -205,7 +205,6 @@ public class XDGspecificationTests extends BrowserTest {
Entry<String, String> entry = it.next();
String v = entry.getValue();
String s = entry.getKey() + "=" + v;
- //System.out.println(s);
if (entry.getKey().equals(XDG_CACHE_HOME) || entry.getKey().equals(XDG_CONFIG_HOME)) {
ServerAccess.logOutputReprint("ignoring " + s);
c++;
@@ -243,7 +242,6 @@ public class XDGspecificationTests extends BrowserTest {
Entry<String, String> entry = it.next();
String v = entry.getValue();
String s = entry.getKey() + "=" + v;
- //System.out.println(s);
if (entry.getKey().equals(XDG_CACHE_HOME)) {
ServerAccess.logOutputReprint(entry.getKey() + " was " + v);
v = cacheF.getAbsolutePath();
diff --git a/tests/test-extensions/net/sourceforge/jnlp/ServerAccess.java b/tests/test-extensions/net/sourceforge/jnlp/ServerAccess.java
index e9f4238..31e81ad 100644
--- a/tests/test-extensions/net/sourceforge/jnlp/ServerAccess.java
+++ b/tests/test-extensions/net/sourceforge/jnlp/ServerAccess.java
@@ -61,6 +61,7 @@ import net.sourceforge.jnlp.browsertesting.Browsers;
import net.sourceforge.jnlp.closinglisteners.AutoErrorClosingListener;
import net.sourceforge.jnlp.closinglisteners.AutoOkClosingListener;
import net.sourceforge.jnlp.util.FileUtils;
+import net.sourceforge.jnlp.util.logging.OutputController;
import org.junit.Assert;
/**
@@ -756,16 +757,7 @@ public class ServerAccess {
logException(t, true);
}
public static void logException(Throwable t, boolean print){
- try{
- StringWriter sw = new StringWriter();
- PrintWriter pw = new PrintWriter(sw);
- t.printStackTrace(pw);
- log(sw.toString(), false, print);
- pw.close();
- sw.close();
- }catch(Exception ex){
- throw new RuntimeException(ex);
- }
+ log(OutputController.exceptionToString(t), false, print);
}
private static StackTraceElement getTestMethod() {
--
cgit v1.2.3