github.com/searKing/golang/go@v1.2.74/boolean/operation_test.go (about)

     1  // Copyright 2020 The searKing Author. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package boolean
     6  
     7  import "testing"
     8  
     9  type input struct {
    10  	a      bool
    11  	b      bool
    12  	c      []bool
    13  	expect bool
    14  }
    15  
    16  func TestAND(t *testing.T) {
    17  	ins := []input{
    18  		{
    19  			a:      true,
    20  			b:      true,
    21  			expect: true,
    22  		},
    23  		{
    24  			a:      true,
    25  			b:      false,
    26  			expect: false,
    27  		},
    28  		{
    29  			a:      false,
    30  			b:      true,
    31  			expect: false,
    32  		},
    33  		{
    34  			a:      false,
    35  			b:      false,
    36  			expect: false,
    37  		},
    38  		{
    39  			a: true,
    40  			b: true,
    41  			c: []bool{
    42  				true,
    43  			},
    44  			expect: true,
    45  		},
    46  		{
    47  			a: true,
    48  			b: true,
    49  			c: []bool{
    50  				false,
    51  				false,
    52  			},
    53  			expect: false,
    54  		},
    55  	}
    56  	for idx, in := range ins {
    57  		if AND(in.a, in.b, in.c...) != in.expect {
    58  			t.Errorf("#%d expect %t", idx, in.expect)
    59  		}
    60  	}
    61  }
    62  
    63  func TestOR(t *testing.T) {
    64  	ins := []input{
    65  		{
    66  			a:      true,
    67  			b:      true,
    68  			expect: true,
    69  		},
    70  		{
    71  			a:      true,
    72  			b:      false,
    73  			expect: true,
    74  		},
    75  		{
    76  			a:      false,
    77  			b:      true,
    78  			expect: true,
    79  		},
    80  		{
    81  			a:      false,
    82  			b:      false,
    83  			expect: false,
    84  		},
    85  		{
    86  			a: false,
    87  			b: false,
    88  			c: []bool{
    89  				true,
    90  			},
    91  			expect: true,
    92  		},
    93  		{
    94  			a: false,
    95  			b: false,
    96  			c: []bool{
    97  				false,
    98  				true,
    99  			},
   100  			expect: true,
   101  		},
   102  	}
   103  	for idx, in := range ins {
   104  		if OR(in.a, in.b, in.c...) != in.expect {
   105  			t.Errorf("#%d expect %t", idx, in.expect)
   106  		}
   107  	}
   108  }
   109  
   110  func TestXOR(t *testing.T) {
   111  	ins := []input{
   112  		{
   113  			a:      true,
   114  			b:      true,
   115  			expect: false,
   116  		},
   117  		{
   118  			a:      true,
   119  			b:      false,
   120  			expect: true,
   121  		},
   122  		{
   123  			a:      false,
   124  			b:      true,
   125  			expect: true,
   126  		},
   127  		{
   128  			a:      false,
   129  			b:      false,
   130  			expect: false,
   131  		},
   132  		{
   133  			a: false,
   134  			b: false,
   135  			c: []bool{
   136  				true,
   137  			},
   138  			expect: true,
   139  		},
   140  		{
   141  			a: false,
   142  			b: false,
   143  			c: []bool{
   144  				false,
   145  				true,
   146  			},
   147  			expect: true,
   148  		},
   149  	}
   150  	for idx, in := range ins {
   151  		if XOR(in.a, in.b, in.c...) != in.expect {
   152  			t.Errorf("#%d expect %t", idx, in.expect)
   153  		}
   154  	}
   155  }
   156  
   157  func TestXNOR(t *testing.T) {
   158  	ins := []input{
   159  		{
   160  			a:      true,
   161  			b:      true,
   162  			expect: true,
   163  		},
   164  		{
   165  			a:      true,
   166  			b:      false,
   167  			expect: false,
   168  		},
   169  		{
   170  			a:      false,
   171  			b:      true,
   172  			expect: false,
   173  		},
   174  		{
   175  			a:      false,
   176  			b:      false,
   177  			expect: true,
   178  		},
   179  		{
   180  			a: false,
   181  			b: false,
   182  			c: []bool{
   183  				true,
   184  			},
   185  			expect: true,
   186  		},
   187  		{
   188  			a: false,
   189  			b: false,
   190  			c: []bool{
   191  				false,
   192  				true,
   193  			},
   194  			expect: false,
   195  		},
   196  	}
   197  	for idx, in := range ins {
   198  		if XNOR(in.a, in.b, in.c...) != in.expect {
   199  			t.Errorf("#%d expect %t", idx, in.expect)
   200  		}
   201  	}
   202  }
   203  func TestBoolFunc(t *testing.T) {
   204  	ins := []input{
   205  		{
   206  			a:      true,
   207  			b:      true,
   208  			expect: true,
   209  		},
   210  		{
   211  			a:      true,
   212  			b:      false,
   213  			expect: false,
   214  		},
   215  		{
   216  			a:      false,
   217  			b:      true,
   218  			expect: false,
   219  		},
   220  		{
   221  			a:      false,
   222  			b:      false,
   223  			expect: false,
   224  		},
   225  		{
   226  			a: true,
   227  			b: true,
   228  			c: []bool{
   229  				false,
   230  			},
   231  			expect: false,
   232  		},
   233  		{
   234  			a: true,
   235  			b: true,
   236  			c: []bool{
   237  				true,
   238  				false,
   239  			},
   240  			expect: false,
   241  		},
   242  	}
   243  	allIsTrue := func(a, b bool) bool {
   244  		if !a || !b {
   245  			return false
   246  		}
   247  		return true
   248  	}
   249  	for idx, in := range ins {
   250  		if BoolFunc(in.a, in.b, allIsTrue, in.c...) != in.expect {
   251  			t.Errorf("#%d expect %t", idx, in.expect)
   252  		}
   253  	}
   254  }