[JBoss JIRA] (DROOLS-4288) Infinite recursion in drools after version change from v7.20 to v7.21
by Geogie Tom (Jira)
[ https://issues.jboss.org/browse/DROOLS-4288?page=com.atlassian.jira.plugi... ]
Geogie Tom updated DROOLS-4288:
-------------------------------
Steps to Reproduce:
Steps to Reproduce are in the description
> Infinite recursion in drools after version change from v7.20 to v7.21
> ---------------------------------------------------------------------
>
> Key: DROOLS-4288
> URL: https://issues.jboss.org/browse/DROOLS-4288
> Project: Drools
> Issue Type: Bug
> Components: core engine
> Affects Versions: 7.21.0.Final, 7.22.0.Final, 7.23.0.Final
> Environment: Both Mac and Windows
> Reporter: Geogie Tom
> Assignee: Mario Fusco
> Priority: Major
>
> When there is a version change in drools-compiler from `7.20.0.Final` to `7.21.0.Final` some rules are looping recursively.
> *Code in github:*
> [The working version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.20]
> [The recursively looping version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.21]
> [The change between working and looping version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> *More details*
> When I fire a rule whose `then` part modifies a fact that is already checked in the `when` part:
> {code:java}
> rule "rule 1.1"
> when
> $sampleDomain: SampleDomain(instanceVariable2 == "Value of instance variable")
> then
> System.out.println("Rule 1.1 fired");
> modify($sampleDomain){
> setInstanceVariable1(3)
> }
> end
> {code}
> it doesn't loop recursively.
> But when I call another rule which call a static function from another class:
> {code:java}
> rule "rule 1.2"
> when
> $sampleDomain: SampleDomain(CoreUtils.anotherFunction())
> then
> System.out.println("Rule 1.2 fired");
> modify($sampleDomain){
> setInstanceVariable1(3)
> }
> end
> {code}
> it loops recursively.
> The class with static function is
> {code:java}
> import com.drool_issue.domain.SampleDomain;
> public class CoreUtils {
>
> public static boolean anotherFunction() {
> System.out.println("anotherFunction() inside CoreUtils");
> return true;
> }
>
> public static boolean anotherFunction(SampleDomain sampleDomain) {
> System.out.println("anotherFunction(SampleDomain sampleDomain) inside CoreUtils");
> return true;
> }
> }
> {code}
> My domain file is:
> {code:java}
> public class SampleDomain {
> private int instanceVariable1;
> private String instanceVariable2;
> private int instanceVariable3;
>
>
> public int getInstanceVariable1() {
> return instanceVariable1;
> }
> public void setInstanceVariable1(int instanceVariable1) {
> this.instanceVariable1 = instanceVariable1;
> }
> public String getInstanceVariable2() {
> return instanceVariable2;
> }
> public void setInstanceVariable2(String instanceVariable2) {
> this.instanceVariable2 = instanceVariable2;
> }
> public int getInstanceVariable3() {
> return instanceVariable3;
> }
> public void setInstanceVariable3(int instanceVariable3) {
> this.instanceVariable3 = instanceVariable3;
> }
>
>
> }
> {code}
> This is only caused after version change from `7.20.0.Final` to `7.21.0.Final`. Any guess on what the problem might be?
> When I further looked into the problem I saw this too.
> When we add two functions into the `SampleDomain` class ie
> {code:java}
> public boolean anotherFunction() {
> return true;
> }
>
> public boolean anotherFunction(SampleDomain sampleDomain) {
> return true;
> }
> {code}
> and use this in the rule like:
> {code:java}
> rule "rule 1.4"
> when
> $sampleDomain: SampleDomain(anotherFunction())
> then
> System.out.println("Rule 1.4 fired");
> modify($sampleDomain){
> setInstanceVariable1(3)
> }
> end
> {code}
> and
> {code:java}
> rule "rule 1.5"
> when
> $sampleDomain: SampleDomain(anotherFunction($sampleDomain))
> then
> System.out.println("Rule 1.5 fired");
> modify($sampleDomain){
> setInstanceVariable3(4)
> }
> end
> {code}
> these also loops recursively.
> *Code in github:*
> [The recursive looping when using non static methods|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7....]
> [The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> Also when any of the static method is made non static then method from the domain class is called even though the static method is specified in the rule.
> *Code portions to be noted here are:*
> [Rule where static method is called.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
> [Another rule which also call the static method.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
> [The static access modifier removed from the functions which where previously static.|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> *Code in github:*
> [Weird behaviour when removing static modifier for the functions.|https://github.com/padippist/DroolsIssueReporting/tree/issue_v...]
> [The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> *All this are caused in versions after `7.20.0.Final`, ie `7.21.0.Final`, `7.22.0.Final` and `7.23.0.Final`*
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
6 years, 10 months
[JBoss JIRA] (DROOLS-4288) Infinite recursion in drools after version change from v7.20 to v7.21
by Geogie Tom (Jira)
[ https://issues.jboss.org/browse/DROOLS-4288?page=com.atlassian.jira.plugi... ]
Geogie Tom updated DROOLS-4288:
-------------------------------
Description:
When there is a version change in drools-compiler from `7.20.0.Final` to `7.21.0.Final` some rules are looping recursively.
*Code in github:*
[The working version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.20]
[The recursively looping version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.21]
[The change between working and looping version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
*More details*
When I fire a rule whose `then` part modifies a fact that is already checked in the `when` part:
{code:java}
rule "rule 1.1"
when
$sampleDomain: SampleDomain(instanceVariable2 == "Value of instance variable")
then
System.out.println("Rule 1.1 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
{code}
it doesn't loop recursively.
But when I call another rule which call a static function from another class:
{code:java}
rule "rule 1.2"
when
$sampleDomain: SampleDomain(CoreUtils.anotherFunction())
then
System.out.println("Rule 1.2 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
{code}
it loops recursively.
The class with static function is
{code:java}
import com.drool_issue.domain.SampleDomain;
public class CoreUtils {
public static boolean anotherFunction() {
System.out.println("anotherFunction() inside CoreUtils");
return true;
}
public static boolean anotherFunction(SampleDomain sampleDomain) {
System.out.println("anotherFunction(SampleDomain sampleDomain) inside CoreUtils");
return true;
}
}
{code}
My domain file is:
{code:java}
public class SampleDomain {
private int instanceVariable1;
private String instanceVariable2;
private int instanceVariable3;
public int getInstanceVariable1() {
return instanceVariable1;
}
public void setInstanceVariable1(int instanceVariable1) {
this.instanceVariable1 = instanceVariable1;
}
public String getInstanceVariable2() {
return instanceVariable2;
}
public void setInstanceVariable2(String instanceVariable2) {
this.instanceVariable2 = instanceVariable2;
}
public int getInstanceVariable3() {
return instanceVariable3;
}
public void setInstanceVariable3(int instanceVariable3) {
this.instanceVariable3 = instanceVariable3;
}
}
{code}
This is only caused after version change from `7.20.0.Final` to `7.21.0.Final`. Any guess on what the problem might be?
When I further looked into the problem I saw this too.
When we add two functions into the `SampleDomain` class ie
{code:java}
public boolean anotherFunction() {
return true;
}
public boolean anotherFunction(SampleDomain sampleDomain) {
return true;
}
{code}
and use this in the rule like:
{code:java}
rule "rule 1.4"
when
$sampleDomain: SampleDomain(anotherFunction())
then
System.out.println("Rule 1.4 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
{code}
and
{code:java}
rule "rule 1.5"
when
$sampleDomain: SampleDomain(anotherFunction($sampleDomain))
then
System.out.println("Rule 1.5 fired");
modify($sampleDomain){
setInstanceVariable3(4)
}
end
{code}
these also loops recursively.
*Code in github:*
[The recursive looping when using non static methods|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7....]
[The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
Also when any of the static method is made non static then method from the domain class is called even though the static method is specified in the rule.
*Code portions to be noted here are:*
[Rule where static method is called.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
[Another rule which also call the static method.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
[The static access modifier removed from the functions which where previously static.|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
*Code in github:*
[Weird behaviour when removing static modifier for the functions.|https://github.com/padippist/DroolsIssueReporting/tree/issue_v...]
[The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
*All this are caused in versions after `7.20.0.Final`, ie `7.21.0.Final`, `7.22.0.Final` and `7.23.0.Final`*
was:
When there is a version change in drools-compiler from `7.20.0.Final` to `7.21.0.Final` some rules are looping recursively.
*Code in github:*
[The working version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.20]
[The recursively looping version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.21]
[The change between working and looping version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
*More details*
When I fire a rule whose `then` part modifies a fact that is already checked in the `when` part:
{code:java}
rule "rule 1.1"
when
$sampleDomain: SampleDomain(instanceVariable2 == "Value of instance variable")
then
System.out.println("Rule 1.1 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
{code}
it doesn't loop recursively.
But when I call another rule which call a static function from another class:
{code:java}
rule "rule 1.2"
when
$sampleDomain: SampleDomain(CoreUtils.anotherFunction())
then
System.out.println("Rule 1.2 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
{code}
it loops recursively.
The class with static function is
{code:java}
import com.drool_issue.domain.SampleDomain;
public class CoreUtils {
public static boolean anotherFunction() {
System.out.println("anotherFunction() inside CoreUtils");
return true;
}
public static boolean anotherFunction(SampleDomain sampleDomain) {
System.out.println("anotherFunction(SampleDomain sampleDomain) inside CoreUtils");
return true;
}
}
{code}
My domain file is:
{code:java}
public class SampleDomain {
private int instanceVariable1;
private String instanceVariable2;
private int instanceVariable3;
public int getInstanceVariable1() {
return instanceVariable1;
}
public void setInstanceVariable1(int instanceVariable1) {
this.instanceVariable1 = instanceVariable1;
}
public String getInstanceVariable2() {
return instanceVariable2;
}
public void setInstanceVariable2(String instanceVariable2) {
this.instanceVariable2 = instanceVariable2;
}
public int getInstanceVariable3() {
return instanceVariable3;
}
public void setInstanceVariable3(int instanceVariable3) {
this.instanceVariable3 = instanceVariable3;
}
}
{code}
This is only caused after version change from `7.20.0.Final` to `7.21.0.Final`. Any guess on what the problem might be?
When I further looked into the problem I saw this too.
When we add two functions into the `SampleDomain` class ie
{code:java}
public boolean anotherFunction() {
return true;
}
public boolean anotherFunction(SampleDomain sampleDomain) {
return true;
}
{code}
and use this in the rule like:
{code:java}
rule "rule 1.4"
when
$sampleDomain: SampleDomain(anotherFunction())
then
System.out.println("Rule 1.4 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
{code}
and
{code:java}
rule "rule 1.5"
when
$sampleDomain: SampleDomain(anotherFunction($sampleDomain))
then
System.out.println("Rule 1.5 fired");
modify($sampleDomain){
setInstanceVariable3(4)
}
end
{code}
these also loops recursively.
*Code in github:*
[The recursive looping when using non static methods|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7....]
[The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
Also when any of the static method is made non static then method from the domain class is called even though the static method is specified in the rule.
*Code portions to be noted here are:*
[Rule where static method is called.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
[Another rule which also call the static method.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
[The static access modifier removed from the functions which where previously static.|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
*Code in github:*
[Weird behaviour when removing static modifier for the functions.|https://github.com/padippist/DroolsIssueReporting/tree/issue_v...]
[The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
All this are caused in versions after `7.20.0.Final`, ie `7.21.0.Final`, `7.22.0.Final` and `7.23.0.Final`
> Infinite recursion in drools after version change from v7.20 to v7.21
> ---------------------------------------------------------------------
>
> Key: DROOLS-4288
> URL: https://issues.jboss.org/browse/DROOLS-4288
> Project: Drools
> Issue Type: Bug
> Components: core engine
> Affects Versions: 7.21.0.Final, 7.22.0.Final, 7.23.0.Final
> Environment: Both Mac and Windows
> Reporter: Geogie Tom
> Assignee: Mario Fusco
> Priority: Major
>
> When there is a version change in drools-compiler from `7.20.0.Final` to `7.21.0.Final` some rules are looping recursively.
> *Code in github:*
> [The working version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.20]
> [The recursively looping version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.21]
> [The change between working and looping version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> *More details*
> When I fire a rule whose `then` part modifies a fact that is already checked in the `when` part:
> {code:java}
> rule "rule 1.1"
> when
> $sampleDomain: SampleDomain(instanceVariable2 == "Value of instance variable")
> then
> System.out.println("Rule 1.1 fired");
> modify($sampleDomain){
> setInstanceVariable1(3)
> }
> end
> {code}
> it doesn't loop recursively.
> But when I call another rule which call a static function from another class:
> {code:java}
> rule "rule 1.2"
> when
> $sampleDomain: SampleDomain(CoreUtils.anotherFunction())
> then
> System.out.println("Rule 1.2 fired");
> modify($sampleDomain){
> setInstanceVariable1(3)
> }
> end
> {code}
> it loops recursively.
> The class with static function is
> {code:java}
> import com.drool_issue.domain.SampleDomain;
> public class CoreUtils {
>
> public static boolean anotherFunction() {
> System.out.println("anotherFunction() inside CoreUtils");
> return true;
> }
>
> public static boolean anotherFunction(SampleDomain sampleDomain) {
> System.out.println("anotherFunction(SampleDomain sampleDomain) inside CoreUtils");
> return true;
> }
> }
> {code}
> My domain file is:
> {code:java}
> public class SampleDomain {
> private int instanceVariable1;
> private String instanceVariable2;
> private int instanceVariable3;
>
>
> public int getInstanceVariable1() {
> return instanceVariable1;
> }
> public void setInstanceVariable1(int instanceVariable1) {
> this.instanceVariable1 = instanceVariable1;
> }
> public String getInstanceVariable2() {
> return instanceVariable2;
> }
> public void setInstanceVariable2(String instanceVariable2) {
> this.instanceVariable2 = instanceVariable2;
> }
> public int getInstanceVariable3() {
> return instanceVariable3;
> }
> public void setInstanceVariable3(int instanceVariable3) {
> this.instanceVariable3 = instanceVariable3;
> }
>
>
> }
> {code}
> This is only caused after version change from `7.20.0.Final` to `7.21.0.Final`. Any guess on what the problem might be?
> When I further looked into the problem I saw this too.
> When we add two functions into the `SampleDomain` class ie
> {code:java}
> public boolean anotherFunction() {
> return true;
> }
>
> public boolean anotherFunction(SampleDomain sampleDomain) {
> return true;
> }
> {code}
> and use this in the rule like:
> {code:java}
> rule "rule 1.4"
> when
> $sampleDomain: SampleDomain(anotherFunction())
> then
> System.out.println("Rule 1.4 fired");
> modify($sampleDomain){
> setInstanceVariable1(3)
> }
> end
> {code}
> and
> {code:java}
> rule "rule 1.5"
> when
> $sampleDomain: SampleDomain(anotherFunction($sampleDomain))
> then
> System.out.println("Rule 1.5 fired");
> modify($sampleDomain){
> setInstanceVariable3(4)
> }
> end
> {code}
> these also loops recursively.
> *Code in github:*
> [The recursive looping when using non static methods|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7....]
> [The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> Also when any of the static method is made non static then method from the domain class is called even though the static method is specified in the rule.
> *Code portions to be noted here are:*
> [Rule where static method is called.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
> [Another rule which also call the static method.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
> [The static access modifier removed from the functions which where previously static.|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> *Code in github:*
> [Weird behaviour when removing static modifier for the functions.|https://github.com/padippist/DroolsIssueReporting/tree/issue_v...]
> [The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> *All this are caused in versions after `7.20.0.Final`, ie `7.21.0.Final`, `7.22.0.Final` and `7.23.0.Final`*
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
6 years, 10 months
[JBoss JIRA] (LOGMGR-257) Create an error manager which asserts some behavior for tests
by James Perkins (Jira)
James Perkins created LOGMGR-257:
------------------------------------
Summary: Create an error manager which asserts some behavior for tests
Key: LOGMGR-257
URL: https://issues.jboss.org/browse/LOGMGR-257
Project: JBoss Log Manager
Issue Type: Task
Reporter: James Perkins
Assignee: James Perkins
Fix For: 2.1.14.Final, 2.2.0.Final, 3.0.0.Final
Since handlers can use an {{ErrorManager}} some kind of error manager which asserts if an error is detected should be created. This should also allow to be set to allow errors well as some tests expect them.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
6 years, 10 months
[JBoss JIRA] (DROOLS-4288) Infinite recursion in drools after version change from v7.20 to v7.21
by Geogie Tom (Jira)
[ https://issues.jboss.org/browse/DROOLS-4288?page=com.atlassian.jira.plugi... ]
Geogie Tom updated DROOLS-4288:
-------------------------------
Description:
When there is a version change in drools-compiler from `7.20.0.Final` to `7.21.0.Final` some rules are looping recursively.
*Code in github:*
[The working version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.20]
[The recursively looping version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.21]
[The change between working and looping version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
*More details*
When I fire a rule whose `then` part modifies a fact that is already checked in the `when` part:
{code:java}
rule "rule 1.1"
when
$sampleDomain: SampleDomain(instanceVariable2 == "Value of instance variable")
then
System.out.println("Rule 1.1 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
{code}
it doesn't loop recursively.
But when I call another rule which call a static function from another class:
{code:java}
rule "rule 1.2"
when
$sampleDomain: SampleDomain(CoreUtils.anotherFunction())
then
System.out.println("Rule 1.2 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
{code}
it loops recursively.
The class with static function is
{code:java}
import com.drool_issue.domain.SampleDomain;
public class CoreUtils {
public static boolean anotherFunction() {
System.out.println("anotherFunction() inside CoreUtils");
return true;
}
public static boolean anotherFunction(SampleDomain sampleDomain) {
System.out.println("anotherFunction(SampleDomain sampleDomain) inside CoreUtils");
return true;
}
}
{code}
My domain file is:
{code:java}
public class SampleDomain {
private int instanceVariable1;
private String instanceVariable2;
private int instanceVariable3;
public int getInstanceVariable1() {
return instanceVariable1;
}
public void setInstanceVariable1(int instanceVariable1) {
this.instanceVariable1 = instanceVariable1;
}
public String getInstanceVariable2() {
return instanceVariable2;
}
public void setInstanceVariable2(String instanceVariable2) {
this.instanceVariable2 = instanceVariable2;
}
public int getInstanceVariable3() {
return instanceVariable3;
}
public void setInstanceVariable3(int instanceVariable3) {
this.instanceVariable3 = instanceVariable3;
}
}
{code}
This is only caused after version change from `7.20.0.Final` to `7.21.0.Final`. Any guess on what the problem might be?
When I further looked into the problem I saw this too.
When we add two functions into the `SampleDomain` class ie
{code:java}
public boolean anotherFunction() {
return true;
}
public boolean anotherFunction(SampleDomain sampleDomain) {
return true;
}
{code}
and use this in the rule like:
{code:java}
rule "rule 1.4"
when
$sampleDomain: SampleDomain(anotherFunction())
then
System.out.println("Rule 1.4 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
{code}
and
{code:java}
rule "rule 1.5"
when
$sampleDomain: SampleDomain(anotherFunction($sampleDomain))
then
System.out.println("Rule 1.5 fired");
modify($sampleDomain){
setInstanceVariable3(4)
}
end
{code}
these also loops recursively.
*Code in github:*
[The recursive looping when using non static methods|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7....]
[The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
Also when any of the static method is made non static then method from the domain class is called even though the static method is specified in the rule.
*Code portions to be noted here are:*
[Rule where static method is called.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
[Another rule which also call the static method.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
[The static access modifier removed from the functions which where previously static.|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
*Code in github:*
[Weird behaviour when removing static modifier for the functions.|https://github.com/padippist/DroolsIssueReporting/tree/issue_v...]
[The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
All this are caused in versions after `7.20.0.Final`, ie `7.21.0.Final`, `7.22.0.Final` and `7.23.0.Final`
was:
When there is a version change in drools-compiler from `7.20.0.Final` to `7.21.0.Final` some rules are looping recursively.
Code in github:
[link title|http://example.com]
[The working version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.20]
[The recursively looping version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.21]
[link title|http://example.com]
[The change between working and looping version](https://github.com/padippist/DroolsIssueReporting/compare/issue_...
**More details**
When I fire a rule whose `then` part modifies a fact that is already checked in the `when` part:
```
rule "rule 1.1"
when
$sampleDomain: SampleDomain(instanceVariable2 == "Value of instance variable")
then
System.out.println("Rule 1.1 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
```
it doesn't loop recursively.
But when I call another rule which call a static function from another class:
```
rule "rule 1.2"
when
$sampleDomain: SampleDomain(CoreUtils.anotherFunction())
then
System.out.println("Rule 1.2 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
```
it loops recursively.
The class with static function is
```
import com.drool_issue.domain.SampleDomain;
public class CoreUtils {
public static boolean anotherFunction() {
System.out.println("anotherFunction() inside CoreUtils");
return true;
}
public static boolean anotherFunction(SampleDomain sampleDomain) {
System.out.println("anotherFunction(SampleDomain sampleDomain) inside CoreUtils");
return true;
}
}
```
My domain file is:
```
public class SampleDomain {
private int instanceVariable1;
private String instanceVariable2;
private int instanceVariable3;
public int getInstanceVariable1() {
return instanceVariable1;
}
public void setInstanceVariable1(int instanceVariable1) {
this.instanceVariable1 = instanceVariable1;
}
public String getInstanceVariable2() {
return instanceVariable2;
}
public void setInstanceVariable2(String instanceVariable2) {
this.instanceVariable2 = instanceVariable2;
}
public int getInstanceVariable3() {
return instanceVariable3;
}
public void setInstanceVariable3(int instanceVariable3) {
this.instanceVariable3 = instanceVariable3;
}
}
```
This is only caused after version change from `7.20.0.Final` to `7.21.0.Final`. Any guess on what the problem might be?
When I further looked into the problem I saw this too.
When we add two functions into the `SampleDomain` class ie
```
public boolean anotherFunction() {
return true;
}
public boolean anotherFunction(SampleDomain sampleDomain) {
return true;
}
```
and use this in the rule like:
```
rule "rule 1.4"
when
$sampleDomain: SampleDomain(anotherFunction())
then
System.out.println("Rule 1.4 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
```
and
```
rule "rule 1.5"
when
$sampleDomain: SampleDomain(anotherFunction($sampleDomain))
then
System.out.println("Rule 1.5 fired");
modify($sampleDomain){
setInstanceVariable3(4)
}
end
```
these also loops recursively.
**Code in github:**
[The recursive looping when using non static methods|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7....]
[The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
Also when any of the static method is made non static then method from the domain class is called even though the static method is specified in the rule.
**Code portions to be noted here are:**
[Rule where static method is called.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
[Another rule which also call the static method.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
[The static access modifier removed from the functions which where previously static.|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
**Code in github:**
[Weird behaviour when removing static modifier for the functions.|https://github.com/padippist/DroolsIssueReporting/tree/issue_v...]
[The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
All this are caused in versions after `7.20.0.Final`, ie `7.21.0.Final`, `7.22.0.Final` and `7.23.0.Final`
> Infinite recursion in drools after version change from v7.20 to v7.21
> ---------------------------------------------------------------------
>
> Key: DROOLS-4288
> URL: https://issues.jboss.org/browse/DROOLS-4288
> Project: Drools
> Issue Type: Bug
> Components: core engine
> Affects Versions: 7.21.0.Final, 7.22.0.Final, 7.23.0.Final
> Environment: Both Mac and Windows
> Reporter: Geogie Tom
> Assignee: Mario Fusco
> Priority: Major
>
> When there is a version change in drools-compiler from `7.20.0.Final` to `7.21.0.Final` some rules are looping recursively.
> *Code in github:*
> [The working version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.20]
> [The recursively looping version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.21]
> [The change between working and looping version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> *More details*
> When I fire a rule whose `then` part modifies a fact that is already checked in the `when` part:
> {code:java}
> rule "rule 1.1"
> when
> $sampleDomain: SampleDomain(instanceVariable2 == "Value of instance variable")
> then
> System.out.println("Rule 1.1 fired");
> modify($sampleDomain){
> setInstanceVariable1(3)
> }
> end
> {code}
> it doesn't loop recursively.
> But when I call another rule which call a static function from another class:
> {code:java}
> rule "rule 1.2"
> when
> $sampleDomain: SampleDomain(CoreUtils.anotherFunction())
> then
> System.out.println("Rule 1.2 fired");
> modify($sampleDomain){
> setInstanceVariable1(3)
> }
> end
> {code}
> it loops recursively.
> The class with static function is
> {code:java}
> import com.drool_issue.domain.SampleDomain;
> public class CoreUtils {
>
> public static boolean anotherFunction() {
> System.out.println("anotherFunction() inside CoreUtils");
> return true;
> }
>
> public static boolean anotherFunction(SampleDomain sampleDomain) {
> System.out.println("anotherFunction(SampleDomain sampleDomain) inside CoreUtils");
> return true;
> }
> }
> {code}
> My domain file is:
> {code:java}
> public class SampleDomain {
> private int instanceVariable1;
> private String instanceVariable2;
> private int instanceVariable3;
>
>
> public int getInstanceVariable1() {
> return instanceVariable1;
> }
> public void setInstanceVariable1(int instanceVariable1) {
> this.instanceVariable1 = instanceVariable1;
> }
> public String getInstanceVariable2() {
> return instanceVariable2;
> }
> public void setInstanceVariable2(String instanceVariable2) {
> this.instanceVariable2 = instanceVariable2;
> }
> public int getInstanceVariable3() {
> return instanceVariable3;
> }
> public void setInstanceVariable3(int instanceVariable3) {
> this.instanceVariable3 = instanceVariable3;
> }
>
>
> }
> {code}
> This is only caused after version change from `7.20.0.Final` to `7.21.0.Final`. Any guess on what the problem might be?
> When I further looked into the problem I saw this too.
> When we add two functions into the `SampleDomain` class ie
> {code:java}
> public boolean anotherFunction() {
> return true;
> }
>
> public boolean anotherFunction(SampleDomain sampleDomain) {
> return true;
> }
> {code}
> and use this in the rule like:
> {code:java}
> rule "rule 1.4"
> when
> $sampleDomain: SampleDomain(anotherFunction())
> then
> System.out.println("Rule 1.4 fired");
> modify($sampleDomain){
> setInstanceVariable1(3)
> }
> end
> {code}
> and
> {code:java}
> rule "rule 1.5"
> when
> $sampleDomain: SampleDomain(anotherFunction($sampleDomain))
> then
> System.out.println("Rule 1.5 fired");
> modify($sampleDomain){
> setInstanceVariable3(4)
> }
> end
> {code}
> these also loops recursively.
> *Code in github:*
> [The recursive looping when using non static methods|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7....]
> [The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> Also when any of the static method is made non static then method from the domain class is called even though the static method is specified in the rule.
> *Code portions to be noted here are:*
> [Rule where static method is called.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
> [Another rule which also call the static method.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
> [The static access modifier removed from the functions which where previously static.|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> *Code in github:*
> [Weird behaviour when removing static modifier for the functions.|https://github.com/padippist/DroolsIssueReporting/tree/issue_v...]
> [The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> All this are caused in versions after `7.20.0.Final`, ie `7.21.0.Final`, `7.22.0.Final` and `7.23.0.Final`
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
6 years, 10 months
[JBoss JIRA] (DROOLS-4288) Infinite recursion in drools after version change from v7.20 to v7.21
by Geogie Tom (Jira)
[ https://issues.jboss.org/browse/DROOLS-4288?page=com.atlassian.jira.plugi... ]
Geogie Tom updated DROOLS-4288:
-------------------------------
Description:
When there is a version change in drools-compiler from `7.20.0.Final` to `7.21.0.Final` some rules are looping recursively.
Code in github:
[link title|http://example.com]
[The working version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.20]
[The recursively looping version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.21]
[link title|http://example.com]
[The change between working and looping version](https://github.com/padippist/DroolsIssueReporting/compare/issue_...
**More details**
When I fire a rule whose `then` part modifies a fact that is already checked in the `when` part:
```
rule "rule 1.1"
when
$sampleDomain: SampleDomain(instanceVariable2 == "Value of instance variable")
then
System.out.println("Rule 1.1 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
```
it doesn't loop recursively.
But when I call another rule which call a static function from another class:
```
rule "rule 1.2"
when
$sampleDomain: SampleDomain(CoreUtils.anotherFunction())
then
System.out.println("Rule 1.2 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
```
it loops recursively.
The class with static function is
```
import com.drool_issue.domain.SampleDomain;
public class CoreUtils {
public static boolean anotherFunction() {
System.out.println("anotherFunction() inside CoreUtils");
return true;
}
public static boolean anotherFunction(SampleDomain sampleDomain) {
System.out.println("anotherFunction(SampleDomain sampleDomain) inside CoreUtils");
return true;
}
}
```
My domain file is:
```
public class SampleDomain {
private int instanceVariable1;
private String instanceVariable2;
private int instanceVariable3;
public int getInstanceVariable1() {
return instanceVariable1;
}
public void setInstanceVariable1(int instanceVariable1) {
this.instanceVariable1 = instanceVariable1;
}
public String getInstanceVariable2() {
return instanceVariable2;
}
public void setInstanceVariable2(String instanceVariable2) {
this.instanceVariable2 = instanceVariable2;
}
public int getInstanceVariable3() {
return instanceVariable3;
}
public void setInstanceVariable3(int instanceVariable3) {
this.instanceVariable3 = instanceVariable3;
}
}
```
This is only caused after version change from `7.20.0.Final` to `7.21.0.Final`. Any guess on what the problem might be?
When I further looked into the problem I saw this too.
When we add two functions into the `SampleDomain` class ie
```
public boolean anotherFunction() {
return true;
}
public boolean anotherFunction(SampleDomain sampleDomain) {
return true;
}
```
and use this in the rule like:
```
rule "rule 1.4"
when
$sampleDomain: SampleDomain(anotherFunction())
then
System.out.println("Rule 1.4 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
```
and
```
rule "rule 1.5"
when
$sampleDomain: SampleDomain(anotherFunction($sampleDomain))
then
System.out.println("Rule 1.5 fired");
modify($sampleDomain){
setInstanceVariable3(4)
}
end
```
these also loops recursively.
**Code in github:**
[The recursive looping when using non static methods|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7....]
[The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
Also when any of the static method is made non static then method from the domain class is called even though the static method is specified in the rule.
**Code portions to be noted here are:**
[Rule where static method is called.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
[Another rule which also call the static method.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
[The static access modifier removed from the functions which where previously static.|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
**Code in github:**
[Weird behaviour when removing static modifier for the functions.|https://github.com/padippist/DroolsIssueReporting/tree/issue_v...]
[The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
All this are caused in versions after `7.20.0.Final`, ie `7.21.0.Final`, `7.22.0.Final` and `7.23.0.Final`
was:
**When there is a version change in drools-compiler from `7.20.0.Final` to `7.21.0.Final` some rules are looping recursively.**
**Code in github:**
[The working version](https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7...
[The recursively looping version](https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7...
[The change between working and looping version](https://github.com/padippist/DroolsIssueReporting/compare/issue_...
**More details**
When I fire a rule whose `then` part modifies a fact that is already checked in the `when` part:
```
rule "rule 1.1"
when
$sampleDomain: SampleDomain(instanceVariable2 == "Value of instance variable")
then
System.out.println("Rule 1.1 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
```
it doesn't loop recursively.
But when I call another rule which call a static function from another class:
```
rule "rule 1.2"
when
$sampleDomain: SampleDomain(CoreUtils.anotherFunction())
then
System.out.println("Rule 1.2 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
```
it loops recursively.
The class with static function is
```
import com.drool_issue.domain.SampleDomain;
public class CoreUtils {
public static boolean anotherFunction() {
System.out.println("anotherFunction() inside CoreUtils");
return true;
}
public static boolean anotherFunction(SampleDomain sampleDomain) {
System.out.println("anotherFunction(SampleDomain sampleDomain) inside CoreUtils");
return true;
}
}
```
My domain file is:
```
public class SampleDomain {
private int instanceVariable1;
private String instanceVariable2;
private int instanceVariable3;
public int getInstanceVariable1() {
return instanceVariable1;
}
public void setInstanceVariable1(int instanceVariable1) {
this.instanceVariable1 = instanceVariable1;
}
public String getInstanceVariable2() {
return instanceVariable2;
}
public void setInstanceVariable2(String instanceVariable2) {
this.instanceVariable2 = instanceVariable2;
}
public int getInstanceVariable3() {
return instanceVariable3;
}
public void setInstanceVariable3(int instanceVariable3) {
this.instanceVariable3 = instanceVariable3;
}
}
```
This is only caused after version change from `7.20.0.Final` to `7.21.0.Final`. Any guess on what the problem might be?
When I further looked into the problem I saw this too.
When we add two functions into the `SampleDomain` class ie
```
public boolean anotherFunction() {
return true;
}
public boolean anotherFunction(SampleDomain sampleDomain) {
return true;
}
```
and use this in the rule like:
```
rule "rule 1.4"
when
$sampleDomain: SampleDomain(anotherFunction())
then
System.out.println("Rule 1.4 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
```
and
```
rule "rule 1.5"
when
$sampleDomain: SampleDomain(anotherFunction($sampleDomain))
then
System.out.println("Rule 1.5 fired");
modify($sampleDomain){
setInstanceVariable3(4)
}
end
```
these also loops recursively.
**Code in github:**
[The recursive looping when using non static methods](https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7...
[The change between working and above version](https://github.com/padippist/DroolsIssueReporting/compare/issue_...
Also when any of the static method is made non static then method from the domain class is called even though the static method is specified in the rule.
**Code portions to be noted here are:**
[Rule where static method is called.](https://github.com/padippist/DroolsIssueReporting/blob/bde2804b2...
[Another rule which also call the static method.](https://github.com/padippist/DroolsIssueReporting/blob/bde2804b2...
[The static access modifier removed from the functions which where previously static.](https://github.com/padippist/DroolsIssueReporting/compare/issue_...
**Code in github:**
[Weird behaviour when removing static modifier for the functions.](https://github.com/padippist/DroolsIssueReporting/tree/issue_...
[The change between working and above version](https://github.com/padippist/DroolsIssueReporting/compare/issue_...
All this are caused in versions after `7.20.0.Final`, ie `7.21.0.Final`, `7.22.0.Final` and `7.23.0.Final`
> Infinite recursion in drools after version change from v7.20 to v7.21
> ---------------------------------------------------------------------
>
> Key: DROOLS-4288
> URL: https://issues.jboss.org/browse/DROOLS-4288
> Project: Drools
> Issue Type: Bug
> Components: core engine
> Affects Versions: 7.21.0.Final, 7.22.0.Final, 7.23.0.Final
> Environment: Both Mac and Windows
> Reporter: Geogie Tom
> Assignee: Mario Fusco
> Priority: Major
>
> When there is a version change in drools-compiler from `7.20.0.Final` to `7.21.0.Final` some rules are looping recursively.
> Code in github:
> [link title|http://example.com]
> [The working version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.20]
> [The recursively looping version|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7.21]
> [link title|http://example.com]
> [The change between working and looping version](https://github.com/padippist/DroolsIssueReporting/compare/issue_...
> **More details**
> When I fire a rule whose `then` part modifies a fact that is already checked in the `when` part:
> ```
> rule "rule 1.1"
> when
> $sampleDomain: SampleDomain(instanceVariable2 == "Value of instance variable")
> then
> System.out.println("Rule 1.1 fired");
> modify($sampleDomain){
> setInstanceVariable1(3)
> }
> end
> ```
> it doesn't loop recursively.
> But when I call another rule which call a static function from another class:
> ```
> rule "rule 1.2"
> when
> $sampleDomain: SampleDomain(CoreUtils.anotherFunction())
> then
> System.out.println("Rule 1.2 fired");
> modify($sampleDomain){
> setInstanceVariable1(3)
> }
> end
> ```
> it loops recursively.
> The class with static function is
> ```
> import com.drool_issue.domain.SampleDomain;
> public class CoreUtils {
>
> public static boolean anotherFunction() {
> System.out.println("anotherFunction() inside CoreUtils");
> return true;
> }
>
> public static boolean anotherFunction(SampleDomain sampleDomain) {
> System.out.println("anotherFunction(SampleDomain sampleDomain) inside CoreUtils");
> return true;
> }
> }
> ```
> My domain file is:
> ```
> public class SampleDomain {
> private int instanceVariable1;
> private String instanceVariable2;
> private int instanceVariable3;
>
>
> public int getInstanceVariable1() {
> return instanceVariable1;
> }
> public void setInstanceVariable1(int instanceVariable1) {
> this.instanceVariable1 = instanceVariable1;
> }
> public String getInstanceVariable2() {
> return instanceVariable2;
> }
> public void setInstanceVariable2(String instanceVariable2) {
> this.instanceVariable2 = instanceVariable2;
> }
> public int getInstanceVariable3() {
> return instanceVariable3;
> }
> public void setInstanceVariable3(int instanceVariable3) {
> this.instanceVariable3 = instanceVariable3;
> }
>
>
> }
> ```
> This is only caused after version change from `7.20.0.Final` to `7.21.0.Final`. Any guess on what the problem might be?
> When I further looked into the problem I saw this too.
> When we add two functions into the `SampleDomain` class ie
> ```
> public boolean anotherFunction() {
> return true;
> }
>
> public boolean anotherFunction(SampleDomain sampleDomain) {
> return true;
> }
> ```
> and use this in the rule like:
> ```
> rule "rule 1.4"
> when
> $sampleDomain: SampleDomain(anotherFunction())
> then
> System.out.println("Rule 1.4 fired");
> modify($sampleDomain){
> setInstanceVariable1(3)
> }
> end
> ```
> and
> ```
> rule "rule 1.5"
> when
> $sampleDomain: SampleDomain(anotherFunction($sampleDomain))
> then
> System.out.println("Rule 1.5 fired");
> modify($sampleDomain){
> setInstanceVariable3(4)
> }
> end
> ```
> these also loops recursively.
> **Code in github:**
> [The recursive looping when using non static methods|https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7....]
> [The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> Also when any of the static method is made non static then method from the domain class is called even though the static method is specified in the rule.
> **Code portions to be noted here are:**
> [Rule where static method is called.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
> [Another rule which also call the static method.|https://github.com/padippist/DroolsIssueReporting/blob/bde2804b25...]
> [The static access modifier removed from the functions which where previously static.|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> **Code in github:**
> [Weird behaviour when removing static modifier for the functions.|https://github.com/padippist/DroolsIssueReporting/tree/issue_v...]
> [The change between working and above version|https://github.com/padippist/DroolsIssueReporting/compare/issue_v...]
> All this are caused in versions after `7.20.0.Final`, ie `7.21.0.Final`, `7.22.0.Final` and `7.23.0.Final`
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
6 years, 10 months
[JBoss JIRA] (WFLY-12229) Missing license info from core feature pack
by Brian Stansberry (Jira)
[ https://issues.jboss.org/browse/WFLY-12229?page=com.atlassian.jira.plugin... ]
Brian Stansberry resolved WFLY-12229.
-------------------------------------
Resolution: Done
> Missing license info from core feature pack
> -------------------------------------------
>
> Key: WFLY-12229
> URL: https://issues.jboss.org/browse/WFLY-12229
> Project: WildFly
> Issue Type: Bug
> Components: Build System
> Affects Versions: 17.0.0.Final
> Reporter: Brian Stansberry
> Assignee: Brian Stansberry
> Priority: Major
> Fix For: 17.0.1.Final, 18.0.0.Beta1
>
>
> The docs/licenses/core-feature-pack-licenses.html file and thus the overall docs/licenses/licenses.html file is missing most of the expected content. Seems to have only org.wildfly.core:wildfly-event-logger and various org.wildfly.security items.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
6 years, 10 months
[JBoss JIRA] (DROOLS-4288) Infinite recursion in drools after version change from v7.20 to v7.21
by Geogie Tom (Jira)
Geogie Tom created DROOLS-4288:
----------------------------------
Summary: Infinite recursion in drools after version change from v7.20 to v7.21
Key: DROOLS-4288
URL: https://issues.jboss.org/browse/DROOLS-4288
Project: Drools
Issue Type: Bug
Components: core engine
Affects Versions: 7.23.0.Final, 7.22.0.Final, 7.21.0.Final
Environment: Both Mac and Windows
Reporter: Geogie Tom
Assignee: Mario Fusco
**When there is a version change in drools-compiler from `7.20.0.Final` to `7.21.0.Final` some rules are looping recursively.**
**Code in github:**
[The working version](https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7...
[The recursively looping version](https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7...
[The change between working and looping version](https://github.com/padippist/DroolsIssueReporting/compare/issue_...
**More details**
When I fire a rule whose `then` part modifies a fact that is already checked in the `when` part:
```
rule "rule 1.1"
when
$sampleDomain: SampleDomain(instanceVariable2 == "Value of instance variable")
then
System.out.println("Rule 1.1 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
```
it doesn't loop recursively.
But when I call another rule which call a static function from another class:
```
rule "rule 1.2"
when
$sampleDomain: SampleDomain(CoreUtils.anotherFunction())
then
System.out.println("Rule 1.2 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
```
it loops recursively.
The class with static function is
```
import com.drool_issue.domain.SampleDomain;
public class CoreUtils {
public static boolean anotherFunction() {
System.out.println("anotherFunction() inside CoreUtils");
return true;
}
public static boolean anotherFunction(SampleDomain sampleDomain) {
System.out.println("anotherFunction(SampleDomain sampleDomain) inside CoreUtils");
return true;
}
}
```
My domain file is:
```
public class SampleDomain {
private int instanceVariable1;
private String instanceVariable2;
private int instanceVariable3;
public int getInstanceVariable1() {
return instanceVariable1;
}
public void setInstanceVariable1(int instanceVariable1) {
this.instanceVariable1 = instanceVariable1;
}
public String getInstanceVariable2() {
return instanceVariable2;
}
public void setInstanceVariable2(String instanceVariable2) {
this.instanceVariable2 = instanceVariable2;
}
public int getInstanceVariable3() {
return instanceVariable3;
}
public void setInstanceVariable3(int instanceVariable3) {
this.instanceVariable3 = instanceVariable3;
}
}
```
This is only caused after version change from `7.20.0.Final` to `7.21.0.Final`. Any guess on what the problem might be?
When I further looked into the problem I saw this too.
When we add two functions into the `SampleDomain` class ie
```
public boolean anotherFunction() {
return true;
}
public boolean anotherFunction(SampleDomain sampleDomain) {
return true;
}
```
and use this in the rule like:
```
rule "rule 1.4"
when
$sampleDomain: SampleDomain(anotherFunction())
then
System.out.println("Rule 1.4 fired");
modify($sampleDomain){
setInstanceVariable1(3)
}
end
```
and
```
rule "rule 1.5"
when
$sampleDomain: SampleDomain(anotherFunction($sampleDomain))
then
System.out.println("Rule 1.5 fired");
modify($sampleDomain){
setInstanceVariable3(4)
}
end
```
these also loops recursively.
**Code in github:**
[The recursive looping when using non static methods](https://github.com/padippist/DroolsIssueReporting/tree/issue_v_7...
[The change between working and above version](https://github.com/padippist/DroolsIssueReporting/compare/issue_...
Also when any of the static method is made non static then method from the domain class is called even though the static method is specified in the rule.
**Code portions to be noted here are:**
[Rule where static method is called.](https://github.com/padippist/DroolsIssueReporting/blob/bde2804b2...
[Another rule which also call the static method.](https://github.com/padippist/DroolsIssueReporting/blob/bde2804b2...
[The static access modifier removed from the functions which where previously static.](https://github.com/padippist/DroolsIssueReporting/compare/issue_...
**Code in github:**
[Weird behaviour when removing static modifier for the functions.](https://github.com/padippist/DroolsIssueReporting/tree/issue_...
[The change between working and above version](https://github.com/padippist/DroolsIssueReporting/compare/issue_...
All this are caused in versions after `7.20.0.Final`, ie `7.21.0.Final`, `7.22.0.Final` and `7.23.0.Final`
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
6 years, 10 months
[JBoss JIRA] (DROOLS-4245) [DMN Designer] Documentation - Enhance presentation
by Guilherme Gomes (Jira)
[ https://issues.jboss.org/browse/DROOLS-4245?page=com.atlassian.jira.plugi... ]
Guilherme Gomes commented on DROOLS-4245:
-----------------------------------------
[~tirelli] Unfortunately, the limitation wasn't overcome. The numbers are automatically added by the browser (Stunner approach relies in the browser to create the PDF). If the user changes the paper size, the number of pages is increase and our table of contents cannot handle it.
> [DMN Designer] Documentation - Enhance presentation
> ---------------------------------------------------
>
> Key: DROOLS-4245
> URL: https://issues.jboss.org/browse/DROOLS-4245
> Project: Drools
> Issue Type: Task
> Components: DMN Editor
> Reporter: Elizabeth Clayton
> Assignee: Brian Dellascio
> Priority: Major
> Labels: UX, UXTeam, VisualDesign, drools-tools
> Attachments: doc.pdf, new_doc.pdf
>
>
> Enhance styles and presentation of the Documentation output.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
6 years, 10 months