diff options
Diffstat (limited to 'tests')
6 files changed, 455 insertions, 33 deletions
diff --git a/tests/reproducers/signed/AppletTestSigned/testcases/AppletTestSignedTests.java b/tests/reproducers/signed/AppletTestSigned/testcases/AppletTestSignedTests.java index 6622514..c7227e7 100644 --- a/tests/reproducers/signed/AppletTestSigned/testcases/AppletTestSignedTests.java +++ b/tests/reproducers/signed/AppletTestSigned/testcases/AppletTestSignedTests.java @@ -43,6 +43,9 @@ import net.sourceforge.jnlp.ServerAccess; import net.sourceforge.jnlp.browsertesting.BrowserTest; import net.sourceforge.jnlp.browsertesting.Browsers; import net.sourceforge.jnlp.annotations.TestInBrowsers; +import net.sourceforge.jnlp.closinglisteners.Rule; +import net.sourceforge.jnlp.closinglisteners.RulesFolowingClosingListener; +import static net.sourceforge.jnlp.closinglisteners.RulesFolowingClosingListener.*; import org.junit.Assert; import org.junit.Test; @@ -50,8 +53,22 @@ import org.junit.Test; public class AppletTestSignedTests extends BrowserTest { private final List<String> l = Collections.unmodifiableList(Arrays.asList(new String[]{"-Xtrustall"})); + private static final String ss = "xception"; + private static final String s0 = "AppletTestSigned was started"; + private static final String s1 = "value1"; + private static final String s2 = "value2"; + private static final String s3 = "AppletTestSigned was initialised"; + private static final String s7 = "AppletTestSigned killing himself after 2000 ms of life"; + private static final ContainsRule exceptionRule = new ContainsRule(ss); + private static final ContainsRule startedRule = new ContainsRule(s0); + private static final ContainsRule variable1Rule = new ContainsRule(s1); + private static final ContainsRule variable2Rule = new ContainsRule(s2); + private static final ContainsRule initialisedRule = new ContainsRule(s3); + private static final ContainsRule killedRule = new ContainsRule(s7); + private static final RulesFolowingClosingListener okListener=new RulesFolowingClosingListener(startedRule, variable1Rule, variable2Rule, initialisedRule, killedRule); + private static final RulesFolowingClosingListener errorListener=new RulesFolowingClosingListener(exceptionRule); - @Test + // @Test public void AppletTestSignedTest() throws Exception { ProcessResult pr = server.executeJavawsHeadless(l, "/AppletTestSigned.jnlp"); evaluateSignedApplet(pr, true); @@ -60,18 +77,12 @@ public class AppletTestSignedTests extends BrowserTest { } private void evaluateSignedApplet(ProcessResult pr, boolean javawsApplet) { - String s3 = "AppletTestSigned was initialised"; - Assert.assertTrue("AppletTestSigned stdout should contain " + s3 + " but didn't", pr.stdout.contains(s3)); - String s0 = "AppletTestSigned was started"; - Assert.assertTrue("AppletTestSigned stdout should contain " + s0 + " but didn't", pr.stdout.contains(s0)); - String s1 = "value1"; - Assert.assertTrue("AppletTestSigned stdout should contain " + s1 + " but didn't", pr.stdout.contains(s1)); - String s2 = "value2"; - Assert.assertTrue("AppletTestSigned stdout should contain " + s2 + " but didn't", pr.stdout.contains(s2)); - String ss = "xception"; - Assert.assertFalse("AppletTestSigned stderr should not contain " + ss + " but did", pr.stderr.contains(ss)); - String s7 = "AppletTestSigned killing himself after 2000 ms of life"; - Assert.assertTrue("AppletTestSigned stdout should contain " + s7 + " but didn't", pr.stdout.contains(s7)); + Assert.assertTrue("AppletTestSigned stdout " + initialisedRule.toPassingString() + " but didn't", initialisedRule.evaluate(pr.stdout)); + Assert.assertTrue("AppletTestSigned stdout " + startedRule.toPassingString() + " but didn't", startedRule.evaluate(pr.stdout)); + Assert.assertTrue("AppletTestSigned stdout " + variable1Rule.toPassingString() + " but didn't", variable1Rule.evaluate(pr.stdout)); + Assert.assertTrue("AppletTestSigned stdout " + variable2Rule.toPassingString() + " but didn't", variable2Rule.evaluate(pr.stdout)); + Assert.assertFalse("AppletTestSigned stderr " + exceptionRule.toFailingString() + " but did", exceptionRule.evaluate(pr.stderr)); + Assert.assertTrue("AppletTestSigned stdout " + killedRule.toPassingString() + " but didn't", killedRule.evaluate(pr.stdout)); if (!javawsApplet) { /*this is working correctly in most browser, but not in all. temporarily disabling String s4 = "AppletTestSigned was stopped"; @@ -87,7 +98,7 @@ public class AppletTestSignedTests extends BrowserTest { public void AppletTestSignedFirefoxTestXslowX() throws Exception { ServerAccess.PROCESS_TIMEOUT = 30 * 1000; try { - ProcessResult pr = server.executeBrowser("/AppletTestSigned2.html"); + ProcessResult pr = server.executeBrowser("/AppletTestSigned2.html", okListener, errorListener); evaluateSignedApplet(pr, false); //Assert.assertTrue(pr.wasTerminated); //Assert.assertEquals((Integer) 0, pr.returnValue); due to destroy is null diff --git a/tests/reproducers/simple/AppletTest/testcases/AppletTestTests.java b/tests/reproducers/simple/AppletTest/testcases/AppletTestTests.java index 588b513..7415565 100644 --- a/tests/reproducers/simple/AppletTest/testcases/AppletTestTests.java +++ b/tests/reproducers/simple/AppletTest/testcases/AppletTestTests.java @@ -35,6 +35,7 @@ obligated to do so. If you do not wish to do so, delete this exception statement from your version. */ +import net.sourceforge.jnlp.closinglisteners.CountingClosingListener; import net.sourceforge.jnlp.ProcessResult; import net.sourceforge.jnlp.ServerAccess; import net.sourceforge.jnlp.browsertesting.BrowserTest; @@ -47,6 +48,24 @@ import org.junit.Test; public class AppletTestTests extends BrowserTest { + private final String s7 = "Aplet killing himself after 2000 ms of life"; + private final String ss = "xception"; + private final String s2 = "value2"; + private final String s1 = "value1"; + private final String s0 = "applet was started"; + private final String s3 = "applet was initialised"; + + private class CountingClosingListenerImpl extends CountingClosingListener { + + @Override + protected boolean isAlowedToFinish(String s) { + if (s.contains(ss)) { + return true; + } + return (s.contains(s0) && s.contains(s1) && s.contains(s2) && s.contains(s3) && s.contains(s7)); + } + } + @Test @TestInBrowsers(testIn = {Browsers.googleChrome}) @NeedsDisplay @@ -55,7 +74,7 @@ public class AppletTestTests extends BrowserTest { try { //System.out.println("connecting AppletInFirefoxTest request in " + getBrowser().toString()); //just verify loging is recording browser - ProcessResult pr1 = server.executeBrowser("/appletAutoTests.html"); + ProcessResult pr1 = server.executeBrowser("/appletAutoTests2.html", new CountingClosingListenerImpl(), new CountingClosingListenerImpl()); if (pr1.process == null) { Assert.assertTrue("If proces was null here, then google-chrome had to not exist, and so " + ServerAccess.UNSET_BROWSER @@ -64,12 +83,12 @@ public class AppletTestTests extends BrowserTest { pr1.deadlyException.getMessage().contains(ServerAccess.UNSET_BROWSER)); return; } - evaluateApplet(pr1,false); + evaluateApplet(pr1, false); Assert.assertTrue(pr1.wasTerminated); //System.out.println("connecting AppletInFirefoxTest request in " + getBrowser().toString()); // just verify loging is recording browser - ServerAccess.ProcessResult pr = server.executeBrowser("/appletAutoTests.html"); - evaluateApplet(pr,false); + ServerAccess.ProcessResult pr = server.executeBrowser("/appletAutoTests2.html", new CountingClosingListenerImpl(), new CountingClosingListenerImpl()); + evaluateApplet(pr, false); Assert.assertTrue(pr.wasTerminated); } finally { ServerAccess.PROCESS_TIMEOUT = 20 * 1000; //back to normal @@ -80,30 +99,24 @@ public class AppletTestTests extends BrowserTest { @NeedsDisplay public void AppletTest() throws Exception { ProcessResult pr = server.executeJavawsHeadless(null, "/AppletTest.jnlp"); - evaluateApplet(pr,true); + evaluateApplet(pr, true); Assert.assertFalse(pr.wasTerminated); Assert.assertEquals((Integer) 0, pr.returnValue); } private void evaluateApplet(ProcessResult pr, boolean javawsApplet) { - String s3 = "applet was initialised"; Assert.assertTrue("AppletTest stdout should contains " + s3 + " bud didn't", pr.stdout.contains(s3)); - String s0 = "applet was started"; Assert.assertTrue("AppletTest stdout should contains " + s0 + " bud didn't", pr.stdout.contains(s0)); - String s1 = "value1"; Assert.assertTrue("AppletTest stdout should contains " + s1 + " bud didn't", pr.stdout.contains(s1)); - String s2 = "value2"; Assert.assertTrue("AppletTest stdout should contains " + s2 + " bud didn't", pr.stdout.contains(s2)); - String ss = "xception"; Assert.assertFalse("AppletTest stderr should not contains " + ss + " but did", pr.stderr.contains(ss)); - String s7 = "Aplet killing himself after 2000 ms of life"; Assert.assertTrue("AppletTest stdout should contains " + s7 + " bud didn't", pr.stdout.contains(s7)); if (!javawsApplet) { /*this is working correctly in most browser, but not in all. temporarily disabling - String s4 = "applet was stopped"; - Assert.assertTrue("AppletTest stdout should contains " + s4 + " bud did't", pr.stdout.contains(s4)); - String s5 = "applet will be destroyed"; - Assert.assertTrue("AppletTest stdout should contains " + s5 + " bud did't", pr.stdout.contains(s5)); + String s4 = "applet was stopped"; + Assert.assertTrue("AppletTest stdout should contain " + s4 + " bud did't", pr.stdout.contains(s4)); + String s5 = "applet will be destroyed"; + Assert.assertTrue("AppletTest stdout should contain " + s5 + " bud did't", pr.stdout.contains(s5)); */ } } @@ -116,8 +129,8 @@ public class AppletTestTests extends BrowserTest { //just verify loging is recordingb rowser ServerAccess.PROCESS_TIMEOUT = 30 * 1000; try { - ProcessResult pr = server.executeBrowser("/appletAutoTests2.html"); - evaluateApplet(pr,false); + ProcessResult pr = server.executeBrowser("/appletAutoTests2.html", new CountingClosingListenerImpl(), new CountingClosingListenerImpl()); + evaluateApplet(pr, false); Assert.assertTrue(pr.wasTerminated); //Assert.assertEquals((Integer) 0, pr.returnValue); due to destroy is null } finally { @@ -132,9 +145,9 @@ public class AppletTestTests extends BrowserTest { //just verify loging is recording browser ServerAccess.PROCESS_TIMEOUT = 30 * 1000; try { - ProcessResult pr = server.executeBrowser("/appletAutoTests.html"); + ProcessResult pr = server.executeBrowser("/appletAutoTests.html", new CountingClosingListenerImpl(), new CountingClosingListenerImpl()); pr.process.destroy(); - evaluateApplet(pr,false); + evaluateApplet(pr, false); Assert.assertTrue(pr.wasTerminated); //Assert.assertEquals((Integer) 0, pr.returnValue); due to destroy is null } finally { diff --git a/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/CountingClosingListener.java b/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/CountingClosingListener.java new file mode 100644 index 0000000..e8d695c --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/CountingClosingListener.java @@ -0,0 +1,60 @@ +/* CountingClosingListener.java +Copyright (C) 2012 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.closinglisteners; + +import net.sourceforge.jnlp.ClosingListener; + +public abstract class CountingClosingListener extends ClosingListener { + + protected StringBuilder sb = new StringBuilder(); + + @Override + public void charReaded(char ch) { + sb.append(ch); + if (isAlowedToFinish(sb.toString())) { + terminate(); + } + + } + + @Override + public void lineReaded(String s) { + //nothing to do + } + + protected abstract boolean isAlowedToFinish(String content); +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/Rule.java b/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/Rule.java new file mode 100644 index 0000000..6c4d679 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/Rule.java @@ -0,0 +1,46 @@ +/* Rule.java +Copyright (C) 2012 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.closinglisteners; + +public interface Rule<S,T> { + + public void setRule(S rule); + public boolean evaluate(T upon); + public String toPassingString(); + public String toFailingString(); + +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/RulesFolowingClosingListener.java b/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/RulesFolowingClosingListener.java new file mode 100644 index 0000000..9eb491c --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/RulesFolowingClosingListener.java @@ -0,0 +1,235 @@ +/* RulesFolowingClosingListener.java +Copyright (C) 2012 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.closinglisteners; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class RulesFolowingClosingListener extends CountingClosingListener { + + private List<Rule> rules = new ArrayList<Rule>(); + + public static class ContainsRule extends StringRule<String> { + + public ContainsRule(String s) { + super(s); + } + + @Override + public boolean evaluate(String upon) { + return (upon.contains(rule)); + } + + @Override + public String toPassingString() { + return "should contain `" + rule + "`"; + } + + @Override + public String toFailingString() { + return "should NOT contain `" + rule + "`"; + } + } + + public static class NotContainsRule extends StringRule<String> { + + public NotContainsRule(String s) { + super(s); + } + + @Override + public boolean evaluate(String upon) { + return !(upon.contains(rule)); + } + + @Override + public String toPassingString() { + return "should NOT contain `" + rule + "`"; + } + + @Override + public String toFailingString() { + return "should contain `" + rule + "`"; + } + } + + public static class MatchesRule extends StringRule<String> { + + public MatchesRule(String s) { + super(s); + } + + @Override + public boolean evaluate(String upon) { + return (upon.matches(rule)); + } + + @Override + public String toPassingString() { + return "should match `" + rule + "`"; + } + + @Override + public String toFailingString() { + return "should NOT match `" + rule + "`"; + } + } + + public static class NotMatchesRule extends StringRule<String> { + + public NotMatchesRule(String s) { + super(s); + } + + @Override + public boolean evaluate(String upon) { + return !(upon.matches(rule)); + } + + @Override + public String toPassingString() { + return "should NOT match`" + rule + "`"; + } + + @Override + public String toFailingString() { + return "should match`" + rule + "`"; + } + } + + + /** + * + * @param rule + * @return self, to alow chaing add(...).add(..)... + */ + public RulesFolowingClosingListener addMatchingRule(String rule) { + this.rules.add(new MatchesRule(rule)); + return this; + } + + /** + * + * @param rule + * @return self, to alow chaing add(...).add(..)... + */ + public RulesFolowingClosingListener addNotMatchingRule(String rule) { + this.rules.add(new NotMatchesRule(rule)); + return this; + } + + /** + * + * @param rule + * @return self, to alow chaing add(...).add(..)... + */ + public RulesFolowingClosingListener addContainsRule(String rule) { + this.rules.add(new ContainsRule(rule)); + return this; + } + + /** + * + * @param rule + * @return self, to alow chaing add(...).add(..)... + */ + public RulesFolowingClosingListener addNotContainsRule(String rule) { + this.rules.add(new NotContainsRule(rule)); + return this; + } + + public RulesFolowingClosingListener() { + } + + public RulesFolowingClosingListener(List<Rule> l) { + addRules(l); + } + + public RulesFolowingClosingListener(Rule... l) { + addRules(l); + } + + public void setRules(List<Rule> rules) { + if (rules == null) { + throw new NullPointerException("rules cant be null"); + } + this.rules = rules; + } + + /** + * no more rules will be possible to add by doing this + * @param rules + */ + public void setRules(Rule[] rules) { + if (rules == null) { + throw new NullPointerException("rules cant be null"); + } + this.rules = Arrays.asList(rules); + } + + public RulesFolowingClosingListener addRules(List<Rule> rules) { + if (rules == null) { + throw new NullPointerException("rules cant be null"); + } + this.rules.addAll(rules); + return this; + } + + public RulesFolowingClosingListener addRules(Rule... rules) { + if (rules == null) { + throw new NullPointerException("rules cant be null"); + } + this.rules.addAll(Arrays.asList(rules)); + return this; + } + + @Override + protected boolean isAlowedToFinish(String content) { + if (rules == null || rules.size() < 1) { + throw new IllegalStateException("No rules specified"); + } + for (Rule rule : rules) { + if (!rule.evaluate(content)) { + return false; + } + } + return true; + + + } +} diff --git a/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/StringRule.java b/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/StringRule.java new file mode 100644 index 0000000..a1ad4a5 --- /dev/null +++ b/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/StringRule.java @@ -0,0 +1,57 @@ +/* StringRule.java +Copyright (C) 2012 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.closinglisteners; + +public abstract class StringRule<T> implements Rule<String, T>{ + protected String rule; + + public StringRule(String rule) { + setRule(rule); + } + + public StringRule() { + } + + + @Override + public void setRule(String rule){ + this.rule=rule; + } + @Override + public abstract boolean evaluate(T upon); + +} |