[jira] [Commented] (LANG-1627) BooleanUtils.xor not behaving as expected with any odd number of true's

["Avijit Chakraborty (Jira)" <ji...@apache.org>]

    [ https://issues.apache.org/jira/browse/LANG-1627?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=17252209#comment-17252209 ] 

Avijit Chakraborty commented on LANG-1627:
------------------------------------------

Hi [~alb-i986],

I had a look into the code of BooleanUtils#xor() methods and at first instance, the implementations looked correct to me.

When Exclusive OR is applied to 2 inputs then the output becomes true when only one of the inputs is true. 

The definition of multi-input exclusive OR gates says that the final output is a 1 when the number of 1s at its inputs is odd, and a 0 when the number of incoming 1s is even. I referred to [https://en.wikipedia.org/wiki/XOR_gate#More_than_two_inputs] 

So, going by this definition (true ^ true ^ true) = true sounds good.

Although I agree with you that the Javadoc of these 2 methods can be improved by including the fact that output will be true if the number of incoming trues are odd.

> BooleanUtils.xor not behaving as expected with any odd number of true's
> -----------------------------------------------------------------------
>
>                 Key: LANG-1627
>                 URL: https://issues.apache.org/jira/browse/LANG-1627
>             Project: Commons Lang
>          Issue Type: Bug
>    Affects Versions: 3.11
>            Reporter: Alberto Scotto
>            Priority: Major
>
> Hi,
> I was expecting a xor function that takes a variable number of arguments to *return true if and only if exactly one among all of the arguments is true*, regardless of the number of arguments.
> This holds true given three false's:
> {code:java}
> @Test
> public void threeFalse() {
>  boolean[] bools = new boolean[]{Boolean.FALSE, Boolean.FALSE, Boolean.FALSE};
>  assertFalse(BooleanUtils.xor(bools));
> }{code}
>  
>  It also holds true given 4 true's, as well as for any even number of trues.
> {code:java}
>     @Test
>     public void fourTrue() {
>         boolean[] bools = new boolean[]{Boolean.TRUE, Boolean.TRUE, Boolean.TRUE, Boolean.TRUE};
>         assertFalse(BooleanUtils.xor(bools));
>     }
> {code}
> The above tests pass.
> But with any odd number of true's that doesn't hold anymore:
>  
> {code:java}
> @Test
> public void threeTrue() {
>  boolean[] bools = new boolean[]{Boolean.TRUE, Boolean.TRUE, Boolean.TRUE};
>  assertFalse(BooleanUtils.xor(bools));
> }
> {code}
> This test fails.
> That was totally unexpected to me.
>  But as it turns out, even
> {noformat}
> true ^ true ^ true{noformat}
> evaluates to true. That was unexpected too to me, at a first sight.
> The thing is that xor (I mean the original boolean operator) is a binary operator, so if you want to make it n-ary, one simple solution is to apply it in two by two: ((a ^ b) ^ c) ^ d
>  And that's what is done in the implementation of the method BooleanUtils#xor.
> But that brings to BooleanUtils.xor(true, true, true) == true, and at the same time BooleanUtils.xor(true, true, true, true) == false, which just doesn't sound right to me.
> Whether or not you agree with me that that is a bug of the method, please at least update the Javadoc, because right now it is not providing the user enough information. Look:
> {code:java}
> Performs an xor on a set of booleans.
>          BooleanUtils.xor(true, true)   = false
>          BooleanUtils.xor(false, false) = false
>          BooleanUtils.xor(true, false)  = true
> {code}
>  
> Thanks.
> Cheers



--
This message was sent by Atlassian Jira
(v8.3.4#803005)