--- a/ChangeLog	Mon Sep 24 17:05:41 2012 +0200
+++ b/ChangeLog	Tue Sep 25 19:04:30 2012 +0200
@@ -1,13 +1,31 @@
+2012-09-25  Jiri Vanek <jvanek@redhat.com>
+
+	Added rules listeners
+	* tests/test-extensions/net/sourceforge/jnlp/closinglisteners/CountingClosingListener.java:
+	Base class for closing listeners which is containing complete output in
+	each time.
+	* tests/test-extensions/net/sourceforge/jnlp/closinglisteners/Rule.java:
+	Class with rule definition for RulesFolowingClosingListener
+	* tests/test-extensions/net/sourceforge/jnlp/closinglisteners/RulesFolowingClosingListener.java:
+	ClosingListener consisted from rules which all have to match for close action
+	* tests/test-extensions/net/sourceforge/jnlp/closinglisteners/StringRule.java:
+	Implementation of rule based on string
+	* tests/reproducers/signed/AppletTestSigned/testcases/AppletTestSignedTests.java:
+	* tests/reproducers/simple/AppletTest/testcases/AppletTestTests.java:
+	Refactored to use Above iisteners.
+
+
 2012-09-24  Jiri Vanek <jvanek@redhat.com>
 
+	Added basic closing listener implementation
 	* tests/reproducers/signed/AppletTestSigned/resources/AppletTestSigned.html:
 	removed unnecessary XslowX
 	* tests/reproducers/signed/AppletTestSigned/resources/AppletTestSigned2.html:
-	aded missing XslowX
+	added missing XslowX
 	* tests/reproducers/signed/AppletTestSigned/srcs/AppletTestSigned.java:
 	added standard closing sentence
 	* tests/reproducers/signed/AppletTestSigned/testcases/AppletTestSignedTests.java:
-	used auto*clsoing listeners
+	used auto*closing listeners
 	* tests/test-extensions/net/sourceforge/jnlp/ClosingListener.java:
 	interface for identifying closing listeners
 	* tests/test-extensions/net/sourceforge/jnlp/ProcessAssasin.java:

--- a/tests/reproducers/signed/AppletTestSigned/testcases/AppletTestSignedTests.java	Mon Sep 24 17:05:41 2012 +0200
+++ b/tests/reproducers/signed/AppletTestSigned/testcases/AppletTestSignedTests.java	Tue Sep 25 19:04:30 2012 +0200
@@ -43,6 +43,9 @@
 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 @@
 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 @@
     }
 
     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 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

--- a/tests/reproducers/simple/AppletTest/testcases/AppletTestTests.java	Mon Sep 24 17:05:41 2012 +0200
+++ b/tests/reproducers/simple/AppletTest/testcases/AppletTestTests.java	Tue Sep 25 19:04:30 2012 +0200
@@ -35,6 +35,7 @@
 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 @@
 
 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 @@
         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 @@
                         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 @@
     @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 @@
         //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 @@
         //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 {

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/CountingClosingListener.java	Tue Sep 25 19:04:30 2012 +0200
@@ -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);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/Rule.java	Tue Sep 25 19:04:30 2012 +0200
@@ -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();
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/RulesFolowingClosingListener.java	Tue Sep 25 19:04:30 2012 +0200
@@ -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;
+
+
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/test-extensions/net/sourceforge/jnlp/closinglisteners/StringRule.java	Tue Sep 25 19:04:30 2012 +0200
@@ -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);
+
+}