1  // SPDX-License-Identifier: AGPL-3.0-or-later
  2  // SPDX-FileCopyrightText: 2025 hyperpolymath
  3  //
  4  // Tests for BetLang Ternary Logic
  5  
  6  import { assertEquals, assertThrows } from '@std/assert';
  7  import {
  8    Ternary,
  9    ternaryAnd,
 10    ternaryOr,
 11    ternaryNot,
 12    ternaryImplies,
 13    ternaryEquivalent,
 14    isDefinite,
 15    isTrue,
 16    isFalse,
 17    isUnknown,
 18    booleanToTernary,
 19    ternaryToBoolean,
 20    tryTernaryToBoolean,
 21  } from '../src/ternary.ts';
 22  
 23  // AND tests
 24  Deno.test('ternaryAnd - T AND T = T', () => {
 25    assertEquals(ternaryAnd('T', 'T'), 'T');
 26  });
 27  
 28  Deno.test('ternaryAnd - T AND U = U', () => {
 29    assertEquals(ternaryAnd('T', 'U'), 'U');
 30  });
 31  
 32  Deno.test('ternaryAnd - T AND F = F', () => {
 33    assertEquals(ternaryAnd('T', 'F'), 'F');
 34  });
 35  
 36  Deno.test('ternaryAnd - U AND U = U', () => {
 37    assertEquals(ternaryAnd('U', 'U'), 'U');
 38  });
 39  
 40  Deno.test('ternaryAnd - U AND F = F', () => {
 41    assertEquals(ternaryAnd('U', 'F'), 'F');
 42  });
 43  
 44  Deno.test('ternaryAnd - F AND F = F', () => {
 45    assertEquals(ternaryAnd('F', 'F'), 'F');
 46  });
 47  
 48  // OR tests
 49  Deno.test('ternaryOr - T OR T = T', () => {
 50    assertEquals(ternaryOr('T', 'T'), 'T');
 51  });
 52  
 53  Deno.test('ternaryOr - T OR U = T', () => {
 54    assertEquals(ternaryOr('T', 'U'), 'T');
 55  });
 56  
 57  Deno.test('ternaryOr - T OR F = T', () => {
 58    assertEquals(ternaryOr('T', 'F'), 'T');
 59  });
 60  
 61  Deno.test('ternaryOr - U OR U = U', () => {
 62    assertEquals(ternaryOr('U', 'U'), 'U');
 63  });
 64  
 65  Deno.test('ternaryOr - U OR F = U', () => {
 66    assertEquals(ternaryOr('U', 'F'), 'U');
 67  });
 68  
 69  Deno.test('ternaryOr - F OR F = F', () => {
 70    assertEquals(ternaryOr('F', 'F'), 'F');
 71  });
 72  
 73  // NOT tests
 74  Deno.test('ternaryNot - NOT T = F', () => {
 75    assertEquals(ternaryNot('T'), 'F');
 76  });
 77  
 78  Deno.test('ternaryNot - NOT F = T', () => {
 79    assertEquals(ternaryNot('F'), 'T');
 80  });
 81  
 82  Deno.test('ternaryNot - NOT U = U', () => {
 83    assertEquals(ternaryNot('U'), 'U');
 84  });
 85  
 86  // Implication tests
 87  Deno.test('ternaryImplies - T => T = T', () => {
 88    assertEquals(ternaryImplies('T', 'T'), 'T');
 89  });
 90  
 91  Deno.test('ternaryImplies - T => F = F', () => {
 92    assertEquals(ternaryImplies('T', 'F'), 'F');
 93  });
 94  
 95  Deno.test('ternaryImplies - F => T = T', () => {
 96    assertEquals(ternaryImplies('F', 'T'), 'T');
 97  });
 98  
 99  Deno.test('ternaryImplies - F => F = T', () => {
100    assertEquals(ternaryImplies('F', 'F'), 'T');
101  });
102  
103  // Helper function tests
104  Deno.test('isDefinite - returns true for T and F', () => {
105    assertEquals(isDefinite('T'), true);
106    assertEquals(isDefinite('F'), true);
107    assertEquals(isDefinite('U'), false);
108  });
109  
110  Deno.test('isTrue/isFalse/isUnknown - correct classification', () => {
111    assertEquals(isTrue('T'), true);
112    assertEquals(isTrue('F'), false);
113    assertEquals(isTrue('U'), false);
114  
115    assertEquals(isFalse('F'), true);
116    assertEquals(isFalse('T'), false);
117    assertEquals(isFalse('U'), false);
118  
119    assertEquals(isUnknown('U'), true);
120    assertEquals(isUnknown('T'), false);
121    assertEquals(isUnknown('F'), false);
122  });
123  
124  Deno.test('booleanToTernary - converts correctly', () => {
125    assertEquals(booleanToTernary(true), 'T');
126    assertEquals(booleanToTernary(false), 'F');
127  });
128  
129  Deno.test('ternaryToBoolean - converts T and F', () => {
130    assertEquals(ternaryToBoolean('T'), true);
131    assertEquals(ternaryToBoolean('F'), false);
132  });
133  
134  Deno.test('ternaryToBoolean - throws on U', () => {
135    assertThrows(
136      () => ternaryToBoolean('U'),
137      Error,
138      'Cannot convert Unknown to boolean'
139    );
140  });
141  
142  Deno.test('tryTernaryToBoolean - returns null for U', () => {
143    assertEquals(tryTernaryToBoolean('T'), true);
144    assertEquals(tryTernaryToBoolean('F'), false);
145    assertEquals(tryTernaryToBoolean('U'), null);
146  });