Add algo for BooleanGateslogic and test cases

Author: VANSH3104

src/main/java/com/thealgorithms/bitmanipulation/BooleanAlgebraGates.java

@@ -3,45 +3,30 @@
 import java.util.List;
 
 /**
- * Implements various Boolean algebra gates (AND, OR, NOT, XOR, NAND, NOR).
- * This class provides the logic for fundamental Boolean operations that can be 
- * used in various computational contexts.
+ * Implements various Boolean algebra gates (AND, OR, NOT, XOR, NAND, NOR)
  */
 public final class BooleanAlgebraGates {
 
-    // Private constructor to prevent instantiation
-    private BooleanAlgebraGates() {}
+    private BooleanAlgebraGates() {
+        // Prevent instantiation
+    }
 
     /**
-     * Interface representing a Boolean gate that takes multiple inputs and returns a result.
+     * Represents a Boolean gate that takes multiple inputs and returns a result.
      */
     interface BooleanGate {
         /**
-         * Evaluates the Boolean gate with the provided inputs.
+         * Evaluates the gate with the given inputs.
          *
-         * @param inputs a list of Boolean values representing the gate inputs.
-         * @return the result of the Boolean operation.
+         * @param inputs The input values for the gate.
+         * @return The result of the evaluation.
          */
         boolean evaluate(List<Boolean> inputs);
     }
 
     /**
      * AND Gate implementation.
-     * Returns true if all inputs are true; otherwise, returns false.
-     *
-     * <p>Test cases for AND Gate:</p>
-     * <ul>
-     *     <li>AND([true, true]) should return true.</li>
-     *     <li>AND([true, false]) should return false.</li>
-     *     <li>AND([false, false]) should return false.</li>
-     *     <li>AND([true, true, true]) should return true.</li>
-     *     <li>AND([true, false, true]) should return false.</li>
-     * </ul>
-     *
-     * <p>Edge case (empty input list):</p>
-     * <ul>
-     *     <li>AND([]) can either return true or throw an exception depending on your design.</li>
-     * </ul>
+     * Returns true if all inputs are true; otherwise, false.
      */
     static class ANDGate implements BooleanGate {
         @Override
@@ -57,20 +42,7 @@ public boolean evaluate(List<Boolean> inputs) {
 
     /**
      * OR Gate implementation.
-     * Returns true if at least one input is true; otherwise, returns false.
-     *
-     * <p>Test cases for OR Gate:</p>
-     * <ul>
-     *     <li>OR([true, false]) should return true.</li>
-     *     <li>OR([false, false]) should return false.</li>
-     *     <li>OR([true, true, false]) should return true.</li>
-     *     <li>OR([false, false, false]) should return false.</li>
-     * </ul>
-     *
-     * <p>Edge case (empty input list):</p>
-     * <ul>
-     *     <li>OR([]) can either return false or throw an exception.</li>
-     * </ul>
+     * Returns true if at least one input is true; otherwise, false.
      */
     static class ORGate implements BooleanGate {
         @Override
@@ -86,25 +58,14 @@ public boolean evaluate(List<Boolean> inputs) {
 
     /**
      * NOT Gate implementation (Unary operation).
-     * Only accepts a single input and returns the negation.
-     *
-     * <p>Test cases for NOT Gate:</p>
-     * <ul>
-     *     <li>NOT(true) should return false.</li>
-     *     <li>NOT(false) should return true.</li>
-     * </ul>
-     *
-     * <p>Edge case:</p>
-     * <ul>
-     *     <li>Not applicable, as NOT is a unary operation and requires a single input.</li>
-     * </ul>
+     * Negates a single input value.
      */
     static class NOTGate {
         /**
-         * Evaluates the negation of a single input.
+         * Evaluates the negation of the input.
          *
          * @param input The input value to be negated.
-         * @return The negation of the input.
+         * @return The negated value.
          */
         public boolean evaluate(boolean input) {
             return !input;
@@ -113,21 +74,7 @@ public boolean evaluate(boolean input) {
 
     /**
      * XOR Gate implementation.
-     * Returns true if an odd number of inputs are true; otherwise, returns false.
-     *
-     * <p>Test cases for XOR Gate:</p>
-     * <ul>
-     *     <li>XOR([true, false]) should return true.</li>
-     *     <li>XOR([true, true]) should return false.</li>
-     *     <li>XOR([false, false]) should return false.</li>
-     *     <li>XOR([true, true, true]) should return true.</li>
-     *     <li>XOR([true, false, true]) should return false.</li>
-     * </ul>
-     *
-     * <p>Edge case:</p>
-     * <ul>
-     *     <li>XOR([]) can either return false or throw an exception.</li>
-     * </ul>
+     * Returns true if an odd number of inputs are true; otherwise, false.
      */
     static class XORGate implements BooleanGate {
         @Override
@@ -142,21 +89,7 @@ public boolean evaluate(List<Boolean> inputs) {
 
     /**
      * NAND Gate implementation.
-     * Returns true if at least one input is false; otherwise, returns false.
-     *
-     * <p>Test cases for NAND Gate:</p>
-     * <ul>
-     *     <li>NAND([true, true]) should return false.</li>
-     *     <li>NAND([true, false]) should return true.</li>
-     *     <li>NAND([false, false]) should return true.</li>
-     *     <li>NAND([true, true, true]) should return false.</li>
-     *     <li>NAND([true, true, false]) should return true.</li>
-     * </ul>
-     *
-     * <p>Edge case:</p>
-     * <ul>
-     *     <li>NAND([]) can either return true or throw an exception.</li>
-     * </ul>
+     * Returns true if at least one input is false; otherwise, false.
      */
     static class NANDGate implements BooleanGate {
         @Override
@@ -167,67 +100,12 @@ public boolean evaluate(List<Boolean> inputs) {
 
     /**
      * NOR Gate implementation.
-     * Returns true if all inputs are false; otherwise, returns false.
-     *
-     * <p>Test cases for NOR Gate:</p>
-     * <ul>
-     *     <li>NOR([true, false]) should return false.</li>
-     *     <li>NOR([false, false]) should return true.</li>
-     *     <li>NOR([false, false, false]) should return true.</li>
-     *     <li>NOR([true, true, false]) should return false.</li>
-     * </ul>
-     *
-     * <p>Edge case:</p>
-     * <ul>
-     *     <li>NOR([]) can either return true or throw an exception.</li>
-     * </ul>
+     * Returns true if all inputs are false; otherwise, false.
      */
     static class NORGate implements BooleanGate {
         @Override
         public boolean evaluate(List<Boolean> inputs) {
             return !new ORGate().evaluate(inputs); // Equivalent to negation of OR
         }
     }
-
-    /**
-     * Edge Cases and Special Scenarios:
-     * 
-     * <p>1. Empty input list:</p>
-     * <ul>
-     *    <li>Test handling of empty input lists for multi-input gates.</li>
-     *    <li>Should throw an exception if the design assumes an empty list is invalid.</li>
-     * </ul>
-     * 
-     * <p>2. Single input for multi-input gates:</p>
-     * <ul>
-     *    <li>AND([true]) -> true</li>
-     *    <li>OR([false]) -> false</li>
-     *    <li>XOR([true]) -> true</li>
-     *    <li>Test behavior with single input as a corner case.</li>
-     * </ul>
-     * 
-     * <p>3. Mixed inputs:</p>
-     * <ul>
-     *    <li>AND([true, false, false, true]) -> false</li>
-     *    <li>Similar tests for OR, XOR, and other gates.</li>
-     * </ul>
-     * 
-     * <p>4. Large input lists:</p>
-     * <ul>
-     *    <li>AND([true, true, ..., true]) with 1,000 true values -> true.</li>
-     *    <li>OR with mostly false and one true -> true.</li>
-     * </ul>
-     * 
-     * <p>5. Randomized tests:</p>
-     * <ul>
-     *    <li>Generate random true/false input lists.</li>
-     *    <li>Validate expected gate outputs, especially for XOR.</li>
-     * </ul>
-     * 
-     * <p>6. Invalid input handling:</p>
-     * <ul>
-     *    <li>Test behavior when null is passed as input or within the list.</li>
-     *    <li>Should either throw an exception or handle per defined behavior.</li>
-     * </ul>
-     */
 }

src/test/java/com/thealgorithms/bitmanipulation/BooleanAlgebraGatesTest.java

@@ -0,0 +1,113 @@
+package com.thealgorithms.bitmanipulation;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Stream;
+import com.thealgorithms.bitmanipulation.BooleanAlgebraGates.ANDGate;
+import com.thealgorithms.bitmanipulation.BooleanAlgebraGates.BooleanGate;
+import com.thealgorithms.bitmanipulation.BooleanAlgebraGates.NANDGate;
+import com.thealgorithms.bitmanipulation.BooleanAlgebraGates.NORGate;
+import com.thealgorithms.bitmanipulation.BooleanAlgebraGates.NOTGate;
+import com.thealgorithms.bitmanipulation.BooleanAlgebraGates.ORGate;
+import com.thealgorithms.bitmanipulation.BooleanAlgebraGates.XORGate;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class BooleanAlgebraGatesTest {
+
+    @ParameterizedTest(name = "ANDGate Test Case {index}: inputs={0} -> expected={1}")
+    @MethodSource("provideAndGateTestCases")
+    void testANDGate(List<Boolean> inputs, boolean expected) {
+        BooleanGate gate = new ANDGate();
+        assertEquals(expected, gate.evaluate(inputs));
+    }
+
+    @ParameterizedTest(name = "ORGate Test Case {index}: inputs={0} -> expected={1}")
+    @MethodSource("provideOrGateTestCases")
+    void testORGate(List<Boolean> inputs, boolean expected) {
+        BooleanGate gate = new ORGate();
+        assertEquals(expected, gate.evaluate(inputs));
+    }
+
+    @ParameterizedTest(name = "NOTGate Test Case {index}: input={0} -> expected={1}")
+    @CsvSource({
+            "true, false",
+            "false, true"
+    })
+    void testNOTGate(boolean input, boolean expected) {
+        NOTGate gate = new NOTGate();
+        assertEquals(expected, gate.evaluate(input));
+    }
+
+    @ParameterizedTest(name = "XORGate Test Case {index}: inputs={0} -> expected={1}")
+    @MethodSource("provideXorGateTestCases")
+    void testXORGate(List<Boolean> inputs, boolean expected) {
+        BooleanGate gate = new XORGate();
+        assertEquals(expected, gate.evaluate(inputs));
+    }
+
+    @ParameterizedTest(name = "NANDGate Test Case {index}: inputs={0} -> expected={1}")
+    @MethodSource("provideNandGateTestCases")
+    void testNANDGate(List<Boolean> inputs, boolean expected) {
+        BooleanGate gate = new NANDGate();
+        assertEquals(expected, gate.evaluate(inputs));
+    }
+
+    @ParameterizedTest(name = "NORGate Test Case {index}: inputs={0} -> expected={1}")
+    @MethodSource("provideNorGateTestCases")
+    void testNORGate(List<Boolean> inputs, boolean expected) {
+        BooleanGate gate = new NORGate();
+        assertEquals(expected, gate.evaluate(inputs));
+    }
+
+    // Helper methods to provide test data for each gate
+
+    static Stream<Object[]> provideAndGateTestCases() {
+        return Stream.of(
+                new Object[]{Arrays.asList(true, true, true), true},
+                new Object[]{Arrays.asList(true, false, true), false},
+                new Object[]{Arrays.asList(false, false, false), false},
+                new Object[]{Collections.emptyList(), true} // AND over no inputs is true
+        );
+    }
+
+    static Stream<Object[]> provideOrGateTestCases() {
+        return Stream.of(
+                new Object[]{Arrays.asList(true, false, false), true},
+                new Object[]{Arrays.asList(false, false, false), false},
+                new Object[]{Arrays.asList(true, true, true), true},
+                new Object[]{Collections.emptyList(), false} // OR over no inputs is false
+        );
+    }
+
+    static Stream<Object[]> provideXorGateTestCases() {
+        return Stream.of(
+                new Object[]{Arrays.asList(true, false, true), false}, // XOR over odd true
+                new Object[]{Arrays.asList(true, false, false), true},  // XOR over single true
+                new Object[]{Arrays.asList(false, false, false), false},// XOR over all false
+                new Object[]{Arrays.asList(true, true), false}          // XOR over even true
+        );
+    }
+
+    static Stream<Object[]> provideNandGateTestCases() {
+        return Stream.of(
+                new Object[]{Arrays.asList(true, true, true), false},   // NAND of all true is false
+                new Object[]{Arrays.asList(true, false), true},         // NAND with one false is true
+                new Object[]{Arrays.asList(false, false), true},        // NAND of all false is true
+                new Object[]{Collections.emptyList(), false}            // NAND over no inputs is false (negation of AND)
+        );
+    }
+
+    static Stream<Object[]> provideNorGateTestCases() {
+        return Stream.of(
+                new Object[]{Arrays.asList(false, false), true},        // NOR of all false is true
+                new Object[]{Arrays.asList(false, true), false},        // NOR with one true is false
+                new Object[]{Arrays.asList(true, true), false},         // NOR of all true is false
+                new Object[]{Collections.emptyList(), true}             // NOR over no inputs is true (negation of OR)
+        );
+    }
+}