{ DL-Pascal Coverage Section 1: Types and Operators }
{ Exercises all integer types, real, char, boolean, }
{ all operators, type casting, and constants.       }
{ Expected: runs without error, displays results.   }
{$D-C-R-}

PROGRAM Section1;

CONST
  MaxByte    = 255;
  MinShort   = -128;
  MaxShort   = 127;
  MaxWord    = 65535;
  MaxInt     = 32767;
  MinInt     = -32768;
  MaxLong    = 2147483647;
  Pi         = 3.14159265358979;
  E          = 2.71828182845905;
  TestStr    = 'Hello';
  CTestChar  = 'A';
  CTestBool  = True;
  HexConst   = $FF;
  BinConst   = 255;

VAR
  { Integer types }
  b   : Byte;
  si  : ShortInt;
  i   : Integer;
  w   : Word;
  li  : LongInt;
  { Real }
  r   : Real;
  { Char and Boolean }
  c   : Char;
  bo  : Boolean;
  { Results }
  res : LongInt;
  ok  : Boolean;

{ ---- display a pass/fail line ---- }
PROCEDURE Check(msg : STRING; passed : Boolean);
BEGIN
  IF passed THEN
    WriteLn('OK  ', msg)
  ELSE
    WriteLn('FAIL ', msg);
END;

{ ---- Integer type ranges ---- }
PROCEDURE TestRanges;
BEGIN
  b  := MaxByte;   Check('Byte max',    b = 255);
  b  := 0;         Check('Byte min',    b = 0);
  si := MaxShort;  Check('ShortInt max',si = 127);
  si := MinShort;  Check('ShortInt min',si = -128);
  i  := MaxInt;    Check('Integer max', i = 32767);
  i  := MinInt;    Check('Integer min', i = -32768);
  w  := MaxWord;   Check('Word max',    w = 65535);
  w  := 0;         Check('Word min',    w = 0);
  li := MaxLong;   Check('LongInt max', li = 2147483647);
  li := -MaxLong-1;Check('LongInt min', li = -2147483648);
END;

{ ---- Arithmetic operators ---- }
PROCEDURE TestArithmetic;
BEGIN
  { Integer arithmetic }
  res := 10 + 3;    Check('Int add',      res = 13);
  res := 10 - 3;    Check('Int sub',      res = 7);
  res := 10 * 3;    Check('Int mul',      res = 30);
  res := 10 DIV 3;  Check('Int div',      res = 3);
  res := 10 MOD 3;  Check('Int mod',      res = 1);
  res := -5;        Check('Unary minus',  res = -5);
  res := +5;        Check('Unary plus',   res = 5);

  { Real arithmetic }
  r := 10.0 + 3.0;  Check('Real add',     r = 13.0);
  r := 10.0 - 3.0;  Check('Real sub',     r = 7.0);
  r := 10.0 * 3.0;  Check('Real mul',     r = 30.0);
  r := 10.0 / 4.0;  Check('Real div',     r = 2.5);
  r := 9 / 5;       Check('Int->Real div',r = 1.8);

  { Mixed integer/real }
  r := 3 * 2.5;     Check('Mixed mul',    r = 7.5);
  r := 7.5 - 3;     Check('Mixed sub',    r = 4.5);
END;

{ ---- Bitwise / logical integer operators ---- }
PROCEDURE TestBitwise;
BEGIN
  res := 5 AND 9;   Check('AND',   res = 1);
  res := 5 OR  9;   Check('OR',    res = 13);
  res := 5 XOR 9;   Check('XOR',   res = 12);
  res := NOT 0;     Check('NOT 0', res = -1);
  res := 5 SHL 2;   Check('SHL',   res = 20);
  res := 20 SHR 2;  Check('SHR',   res = 5);
  res := $F0 AND $0F; Check('AND hex', res = 0);
  res := $F0 OR  $0F; Check('OR  hex', res = $FF);
  res := $FF XOR $0F; Check('XOR hex', res = $F0);
END;

{ ---- Comparison operators ---- }
PROCEDURE TestComparisons;
BEGIN
  Check('Int <',   3 < 5);
  Check('Int >',   5 > 3);
  Check('Int =',   5 = 5);
  Check('Int <>',  5 <> 3);
  Check('Int <=',  5 <= 5);
  Check('Int >=',  5 >= 5);
  Check('Real <',  1.5 < 2.5);
  Check('Real >',  2.5 > 1.5);
  Check('Real =',  1.5 = 1.5);
  Check('Real <>', 1.5 <> 2.5);
  Check('Char <',  'A' < 'B');
  Check('Char =',  'A' = 'A');
  Check('Char >',  'B' > 'A');
END;

{ ---- Boolean operators ---- }
PROCEDURE TestBoolean;
BEGIN
  Check('AND TT', True  AND True  = True);
  Check('AND TF', True  AND False = False);
  Check('AND FT', False AND True  = False);
  Check('AND FF', False AND False = False);
  Check('OR TT',  True  OR  True  = True);
  Check('OR TF',  True  OR  False = True);
  Check('OR FT',  False OR  True  = True);
  Check('OR FF',  False OR  False = False);
  Check('XOR TF', True  XOR False = True);
  Check('XOR TT', True  XOR True  = False);
  Check('NOT T',  NOT True  = False);
  Check('NOT F',  NOT False = True);

  { Short-circuit: second part must not be evaluated if first is false }
  i := 0;
  bo := (i <> 0) AND (MaxInt DIV i > 0);  { would div-by-zero without short-circuit }
  Check('Short-circuit AND', bo = False);

  { Short-circuit OR: second part skipped if first is true }
  bo := True OR (i = 1);
  Check('Short-circuit OR', bo = True);
END;

{ ---- Type casting ---- }
PROCEDURE TestTypeCast;
BEGIN
  { Byte overflow without cast }
  b := 255;
  i := Integer(b) + 2;
  Check('Byte->Integer cast', i = 257);

  { Word cast }
  i := -1;
  w := Word(i);
  Check('Integer->Word cast', w = 65535);

  { LongInt cast }
  w := 65535;
  li := LongInt(w) + 1;
  Check('Word->LongInt cast', li = 65536);

  { Real to integer }
  r  := 3.7;
  i  := Trunc(r);
  Check('Trunc 3.7', i = 3);
  i  := Round(r);
  Check('Round 3.7', i = 4);
  r  := -3.7;
  i  := Trunc(r);
  Check('Trunc -3.7', i = -3);
  i  := Round(r);
  Check('Round -3.7', i = -4);

  { Char/Byte conversions }
  c := Chr(65);
  Check('Chr(65)=A', c = 'A');
  b := Ord('A');
  Check('Ord(A)=65', b = 65);
END;

{ ---- Char operations ---- }
PROCEDURE TestChar;
BEGIN
  c := CTestChar;
  Check('Char assign',    c = 'A');
  c := Succ('A'); Check('Char succ', c = 'B');
  c := Pred('B'); Check('Char pred', c = 'A');
  Check('UpCase lower',   UpCase('a') = 'A');
  Check('UpCase upper',   UpCase('A') = 'A');
  Check('Char in set',    c IN ['A'..'Z']);
  Check('Digit in set',   '5' IN ['0'..'9']);
  Check('Not in set',     NOT ('a' IN ['A'..'Z']));
END;

{ ---- Hex and constant expressions ---- }
PROCEDURE TestConstants;
BEGIN
  Check('Hex $FF=255',    HexConst = 255);
  Check('Pi approx',      (Pi > 3.141) AND (Pi < 3.142));
  Check('E approx',       (E > 2.718) AND (E < 2.719));
  Check('Const bool',     CTestBool = True);
  Check('Const char',     CTestChar = 'A');
  res := MaxByte + 1;
  Check('Const expr',     res = 256);
END;

{ ---- Inc / Dec ---- }
PROCEDURE TestIncDec;
BEGIN
  i := 5;
  Inc(i);       Check('Inc by 1',  i = 6);
  Inc(i, 4);    Check('Inc by 4',  i = 10);
  Dec(i);       Check('Dec by 1',  i = 9);
  Dec(i, 4);    Check('Dec by 4',  i = 5);

  { On Byte wrap }
  b := 0;
  Dec(b);       Check('Byte Dec wrap', b = 255);
  b := 255;
  Inc(b);       Check('Byte Inc wrap', b = 0);
END;

{ ---- Odd / Abs ---- }
PROCEDURE TestMiscFuncs;
BEGIN
  Check('Odd 3',    Odd(3));
  Check('Odd 4',    NOT Odd(4));
  Check('Odd 0',    NOT Odd(0));
  Check('Odd -1',   Odd(-1));

  i := -7;
  Check('Abs neg int',  Abs(i) = 7);
  i := 7;
  Check('Abs pos int',  Abs(i) = 7);
  r := -3.5;
  Check('Abs neg real', Abs(r) = 3.5);

  Check('Sqr 4',    Sqr(4) = 16);
  Check('Sqr -3',   Sqr(-3) = 9);
  r := Sqrt(4.0);
  Check('Sqrt 4',   r = 2.0);
  r := Sqrt(2.0);
  Check('Sqrt 2',   (r > 1.414) AND (r < 1.415));
END;

{ ---- Succ / Pred on integers ---- }
PROCEDURE TestSuccPred;
BEGIN
  i := Succ(5); Check('Succ 5', i = 6);
  i := Pred(5); Check('Pred 5', i = 4);
  i := Succ(-1); Check('Succ -1', i = 0);
  i := Pred(0); Check('Pred 0', i = -1);
END;

{ ---- Main ---- }
BEGIN
  WriteLn('=== Section 1: Types and Operators ===');
  WriteLn;

  WriteLn('-- Ranges --');
  TestRanges;
  WriteLn;

  WriteLn('-- Arithmetic --');
  TestArithmetic;
  WriteLn;

  WriteLn('-- Bitwise --');
  TestBitwise;
  WriteLn;

  WriteLn('-- Comparisons --');
  TestComparisons;
  WriteLn;

  WriteLn('-- Boolean --');
  TestBoolean;
  WriteLn;

  WriteLn('-- Type Cast --');
  TestTypeCast;
  WriteLn;

  WriteLn('-- Char --');
  TestChar;
  WriteLn;

  WriteLn('-- Constants --');
  TestConstants;
  WriteLn;

  WriteLn('-- Inc/Dec --');
  TestIncDec;
  WriteLn;

  WriteLn('-- Misc --');
  TestMiscFuncs;
  WriteLn;

  WriteLn('-- Succ/Pred --');
  TestSuccPred;
  WriteLn;

  WriteLn('=== Section 1 complete ===');
END.