diff --git a/lib/src/signals/logic.dart b/lib/src/signals/logic.dart
index 8de96bafc..60e19a912 100644
--- a/lib/src/signals/logic.dart
+++ b/lib/src/signals/logic.dart
@@ -319,35 +319,21 @@ class Logic {
   void operator <=(Logic other) => gets(other);
 
   /// Logical bitwise NOT.
-  Logic operator ~() {
-    if (this is Const) {
-      if (value.isValid) {
-        if (value == LogicValue.of(0, width: width)) {
-          return Const(LogicValue.filled(width, LogicValue.one));
-        } else if (value == LogicValue.filled(width, LogicValue.one)) {
-          return Const(LogicValue.of(0, width: width));
-        }
-      } else {
-        return Const(LogicValue.x, width: width);
-      }
-    }
-    return NotGate(this).out;
-  }
+  Logic operator ~() => this is Const ? Const(~value) : NotGate(this).out;
 
   /// Logical bitwise AND.
   Logic operator &(Logic other) {
-    if (this is Const || other is Const) {
-      if (value.isValid && other.value.isValid) {
-        if (value == LogicValue.of(0, width: width) ||
-            other.value == LogicValue.of(0, width: width)) {
-          return Const(LogicValue.of(0, width: width));
-        } else if (value == LogicValue.filled(width, LogicValue.one)) {
-          return other;
-        } else if (other.value == LogicValue.filled(width, LogicValue.one)) {
-          return this;
-        }
-      } else {
-        return Const(LogicValue.x, width: width);
+    if (this is Const &&
+        other is Const &&
+        value.isValid &&
+        other.value.isValid) {
+      if (value == LogicValue.of(0, width: width) ||
+          other.value == LogicValue.of(0, width: width)) {
+        return Const(LogicValue.of(0, width: width));
+      } else if (value == LogicValue.filled(width, LogicValue.one)) {
+        return other;
+      } else if (other.value == LogicValue.filled(width, LogicValue.one)) {
+        return this;
       }
     }
     return And2Gate(this, other).out;
@@ -355,19 +341,17 @@ class Logic {
 
   /// Logical bitwise OR.
   Logic operator |(Logic other) {
-    if (this is Const || other is Const) {
-      if (value.isValid && other.value.isValid) {
-        if (value == LogicValue.filled(width, LogicValue.one) ||
-            other.value == LogicValue.filled(width, LogicValue.one)) {
-          return Const(LogicValue.filled(width, LogicValue.one));
-        } else if (value == LogicValue.of(LogicValue.zero, width: width)) {
-          return other;
-        } else if (other.value ==
-            LogicValue.of(LogicValue.zero, width: width)) {
-          return this;
-        }
-      } else {
-        return Const(LogicValue.x, width: width);
+    if (this is Const &&
+        other is Const &&
+        value.isValid &&
+        other.value.isValid) {
+      if (value == LogicValue.filled(width, LogicValue.one) ||
+          other.value == LogicValue.filled(width, LogicValue.one)) {
+        return Const(LogicValue.filled(width, LogicValue.one));
+      } else if (value == LogicValue.of(LogicValue.zero, width: width)) {
+        return other;
+      } else if (other.value == LogicValue.of(LogicValue.zero, width: width)) {
+        return this;
       }
     }
     return Or2Gate(this, other).out;
diff --git a/test/gate_test.dart b/test/gate_test.dart
index 3665164ec..b58b7cd27 100644
--- a/test/gate_test.dart
+++ b/test/gate_test.dart
@@ -361,30 +361,25 @@ void main() {
       final d = Const(LogicValue.one, width: 1);
       a.put(LogicValue.one);
 
-      final result = ~b;
-      expect(result, isA<Const>());
-      expect(result.value, equals(LogicValue.one));
+      expect(~b, isA<Const>());
+      expect((~b).value, equals(LogicValue.one));
 
-      final result2 = ~c;
-      expect(result2, isA<Const>());
-      expect(result2.value, equals(LogicValue.x));
+      expect(~c, isA<Const>());
+      expect((~c).value, equals(LogicValue.x));
 
-      final result3 = ~d;
-      expect(result3, isA<Const>());
-      expect(result3.value, equals(LogicValue.zero));
+      expect(~d, isA<Const>());
+      expect((~d).value, equals(LogicValue.zero));
     });
 
     test('NotGate Multi bit Constant input', () async {
       final b = Const(bin('1111'), width: 4);
       final c = Const(bin('0100'), width: 4);
-      final result = ~b;
 
-      expect(result, isA<Const>());
-      expect(result.value, equals(LogicValue.of(LogicValue.zero, width: 4)));
+      expect(~b, isA<Const>());
+      expect((~b).value, equals(LogicValue.of(LogicValue.zero, width: 4)));
 
-      final result2 = ~c;
-      expect(result2, isA<Logic>());
-      expect(result2.value, equals(LogicValue.of(11, width: 4)));
+      expect(~c, isA<Logic>());
+      expect((~c).value, equals(LogicValue.of(11, width: 4)));
     });
 
     test('And2Gate Single bit Constant input', () async {
@@ -394,31 +389,42 @@ void main() {
       final d = Const(LogicValue.one, width: 1);
       a.put(LogicValue.one);
 
-      final result = a & b;
-      expect(result, isA<Const>());
-      expect(result.value, equals(LogicValue.zero));
+      expect(a & b, isA<Logic>());
+      expect((a & b).value, equals(LogicValue.zero));
 
-      final result2 = a & c;
-      expect(result2, isA<Const>());
-      expect(result2.value, equals(LogicValue.x));
+      expect(a & c, isA<Logic>());
+      expect((a & c).value, equals(LogicValue.x));
 
-      final result3 = a & d;
-      expect(result3, isA<Logic>());
-      expect(result3.value, equals(a.value));
+      expect(b & c, isA<Logic>());
+      expect((b & c).value, equals(LogicValue.zero));
+
+      expect(a & d, isA<Logic>());
+      expect((a & d).value, equals(a.value));
+
+      expect(b & d, isA<Const>());
+      expect((b & d).value, equals(LogicValue.zero));
     });
 
     test('And2Gate Multi bit Constant input', () async {
       final a = Const(LogicValue.of(LogicValue.zero, width: 4));
-      final b = Const(bin('1111'), width: 4);
-      final c = Const(bin('0100'), width: 4);
-      final result = a & c;
+      final b = Const('1111', width: 4);
+      final c = Const('0100', width: 4);
+      final d = Const(1, width: 32, fill: true);
+      final e = Const('10110', width: 32);
+      final z = Const('11111', width: 5);
+      final y = Const(LogicValue.of('11x01', width: 5));
 
-      expect(result, isA<Const>());
-      expect(result.value, equals(LogicValue.of(LogicValue.zero, width: 4)));
+      expect(a & c, isA<Const>());
+      expect((a & c).value, equals(LogicValue.of(LogicValue.zero, width: 4)));
 
-      final result2 = b & c;
-      expect(result2, isA<Logic>());
-      expect(result2.value, equals(c.value));
+      expect(b & c, isA<Logic>());
+      expect((b & c).value, equals(c.value));
+
+      expect(d & e, isA<Const>());
+      expect((d & e).value, equals(LogicValue.of('10110', width: 32)));
+
+      expect(y & z, isA<Logic>());
+      expect((y & z).value, equals(LogicValue.of('11x01', width: 5)));
     });
 
     test('OR2Gate Single bit Constant input', () async {
@@ -426,33 +432,33 @@ void main() {
       final b = Const(LogicValue.zero, width: 1);
       final c = Const(LogicValue.x, width: 1);
       final d = Const(LogicValue.one, width: 1);
+      final z = Const('11111', width: 5);
+      final y = Const(LogicValue.of('11x01', width: 5));
       a.put(LogicValue.one);
 
-      final result = a | b;
-      expect(result, isA<Logic>());
-      expect(result.value, equals(a.value));
+      expect(a | b, isA<Logic>());
+      expect((a | b).value, equals(a.value));
+
+      expect(a | c, isA<Logic>());
+      expect((a | c).value, equals(LogicValue.one));
 
-      final result2 = a | c;
-      expect(result2, isA<Const>());
-      expect(result2.value, equals(LogicValue.x));
+      expect(a | d, isA<Logic>());
+      expect((a | d).value, equals(LogicValue.one));
 
-      final result3 = a | d;
-      expect(result3, isA<Const>());
-      expect(result3.value, equals(LogicValue.one));
+      expect(y | z, isA<Logic>());
+      expect((y | z).value, equals(LogicValue.of('11111', width: 5)));
     });
 
     test('OR2Gate Multi bit Constant input', () async {
       final a = Const(LogicValue.of(LogicValue.zero, width: 4));
       final b = Const(bin('1111'), width: 4);
       final c = Const(bin('0100'), width: 4);
-      final result = a | c;
 
-      expect(result, isA<Logic>());
-      expect(result.value, equals(c.value));
+      expect(a | c, isA<Logic>());
+      expect((a | c).value, equals(c.value));
 
-      final result2 = b | c;
-      expect(result2, isA<Const>());
-      expect(result2.value, equals(LogicValue.filled(4, LogicValue.one)));
+      expect(b | c, isA<Const>());
+      expect((b | c).value, equals(LogicValue.filled(4, LogicValue.one)));
     });
   });