Add covenant SPDX headers to every remaining unmarked source file

f7ccd08 verified 14 days ago

7.31 kB

{ SPDX-License-Identifier: LicenseRef-Sovereign-Leviathan-SL-AGPL3-001
   Licensing: see LICENSE in the repository root. }

{ Test Suite: Comprehensive conformance tests for NraayTensor reference implementation.
  Tests core operations, governance properties, and state machine transitions.
}

unit tests;

{$MODE FPC}

interface

uses
  descriptor, buffer, tensor_array, ownership, governance, materialize, tensor, validation;

type
  { Test statistics }
  TTestStats = record
    total_tests: integer;
    passed: integer;
    failed: integer;
  end;

{ Run all conformance tests }
function RunAllTests: TTestStats;

{ Test: Tensor allocation }
function TestAllocation: boolean;

{ Test: Element get/set }
function TestElementAccess: boolean;

{ Test: Clone creates shared reference }
function TestClone: boolean;

{ Test: Slicing creates non-contiguous view }
function TestSlicing: boolean;

{ Test: Transpose permutes axes }
function TestTranspose: boolean;

{ Test: Materialization restores contiguity }
function TestMaterialization: boolean;

{ Test: Generation tracking }
function TestGenerationTracking: boolean;

{ Test: Governance lemmas }
function TestGovernanceLemmas: boolean;

{ Test: Buffer reference counting }
function TestRefCounting: boolean;

{ Test: Composite workflow }
function TestCompositeWorkflow: boolean;

implementation

var
  test_stats: TTestStats;

function TestAllocation: boolean;
var
  t: TNraayTensor;
  shape: array [0..1] of uint32;
begin
  shape[0] := 3;
  shape[1] := 4;

  t := CreateTensor(shape);
  result := IsValid(t);

  if result then
  begin
    result := (Length(t) = 12) and (Rank(t) = 2);
  end;

  DestroyTensor(t);
end;

function TestElementAccess: boolean;
var
  t: TNraayTensor;
  shape: array [0..1] of uint32;
  coord: array [0..1] of uint32;
begin
  shape[0] := 2;
  shape[1] := 3;

  t := CreateTensor(shape);

  coord[0] := 1;
  coord[1] := 2;
  SetElement(t, coord, 42.0);

  result := (GetElement(t, coord) = 42.0);

  DestroyTensor(t);
end;

function TestClone: boolean;
var
  t1, t2: TNraayTensor;
  shape: array [0..1] of uint32;
begin
  shape[0] := 2;
  shape[1] := 2;

  t1 := CreateTensor(shape);
  t2 := CloneTensor(t1);

  { Both should share same buffer }
  result := (GetDataPtr(t1.data) = GetDataPtr(t2.data));

  { Refcount should be 2 }
  if result then
    result := (GetRefCount(t2.data) = 2);

  DestroyTensor(t1);
  DestroyTensor(t2);
end;

function TestSlicing: boolean;
var
  t: TNraayTensor;
  sliced: TNraayTensor;
  shape: array [0..1] of uint32;
  ranges: array [0..1] of array of uint32;
begin
  shape[0] := 5;
  shape[1] := 5;

  t := CreateTensor(shape);

  { Create dummy ranges for slicing }
  setlength(ranges[0], 3);
  setlength(ranges[1], 3);
  ranges[0][0] := 1;
  ranges[0][1] := 4;
  ranges[0][2] := 1;
  ranges[1][0] := 1;
  ranges[1][1] := 4;
  ranges[1][2] := 1;

  sliced := Slice(t, ranges);

  { Sliced should not be contiguous }
  result := (sliced.descriptor.is_contiguous = 0);

  { Should be in SHARED state }
  if result then
    result := (sliced.descriptor.owns_storage = 0);

  DestroyTensor(t);
  DestroyTensor(sliced);
end;

function TestTranspose: boolean;
var
  t: TNraayTensor;
  transposed: TNraayTensor;
  shape: array [0..1] of uint32;
  perm: array [0..1] of uint32;
begin
  shape[0] := 3;
  shape[1] := 4;

  t := CreateTensor(shape);

  perm[0] := 1;
  perm[1] := 0;

  transposed := Transpose(t, perm);

  { Shape should be swapped }
  result := (transposed.descriptor.shape_ptr^[0] = 4) and
            (transposed.descriptor.shape_ptr^[1] = 3);

  DestroyTensor(t);
  DestroyTensor(transposed);
end;

function TestMaterialization: boolean;
var
  t: TNraayTensor;
  shape: array [0..1] of uint32;
begin
  shape[0] := 2;
  shape[1] := 2;

  t := CreateTensor(shape);

  { Should already be materialized }
  result := (t.descriptor.is_contiguous = 1) and
            (t.descriptor.owns_storage = 1);

  Materialize(t);

  result := result and
            (t.descriptor.is_contiguous = 1) and
            (t.descriptor.owns_storage = 1) and
            (t.descriptor.offset = 0);

  DestroyTensor(t);
end;

function TestGenerationTracking: boolean;
var
  t: TNraayTensor;
  shape: array [0..0] of uint32;
  gen1, gen2: uint32;
begin
  shape[0] := 5;

  t := CreateTensor(shape);
  gen1 := t.descriptor.generation;

  result := (gen1 >= 0);

  DestroyTensor(t);
end;

function TestGovernanceLemmas: boolean;
var
  t: TNraayTensor;
  shape: array [0..1] of uint32;
begin
  shape[0] := 2;
  shape[1] := 3;

  t := CreateTensor(shape);

  { All lemmas should verify }
  result := VerifyGovernanceLemmas(t, t.data.buffer);

  DestroyTensor(t);
end;

function TestRefCounting: boolean;
var
  t1, t2, t3: TNraayTensor;
  shape: array [0..0] of uint32;
  count: uint32;
begin
  shape[0] := 10;

  t1 := CreateTensor(shape);
  count := GetRefCount(t1.data);
  result := (count = 1);

  t2 := CloneTensor(t1);
  count := GetRefCount(t2.data);
  result := result and (count = 2);

  t3 := CloneTensor(t2);
  count := GetRefCount(t3.data);
  result := result and (count = 3);

  DestroyTensor(t1);
  DestroyTensor(t2);
  DestroyTensor(t3);
end;

function TestCompositeWorkflow: boolean;
var
  t1, t2, sliced, materialized: TNraayTensor;
  shape: array [0..1] of uint32;
  ranges: array [0..1] of array of uint32;
  coord: array [0..1] of uint32;
begin
  shape[0] := 4;
  shape[1] := 4;

  t1 := CreateTensor(shape);
  result := IsValid(t1);

  { Set a value }
  coord[0] := 2;
  coord[1] := 2;
  SetElement(t1, coord, 3.14);
  result := result and (GetElement(t1, coord) = 3.14);

  { Clone }
  t2 := CloneTensor(t1);
  result := result and (GetRefCount(t2.data) = 2);

  { Materialize }
  Materialize(t2);
  result := result and (t2.descriptor.is_contiguous = 1);

  DestroyTensor(t1);
  DestroyTensor(t2);
end;

function RunAllTests: TTestStats;
begin
  with result do
  begin
    total_tests := 0;
    passed := 0;
    failed := 0;
  end;

  { Test allocation }
  inc(result.total_tests);
  if TestAllocation then
    inc(result.passed)
  else
    inc(result.failed);

  { Test element access }
  inc(result.total_tests);
  if TestElementAccess then
    inc(result.passed)
  else
    inc(result.failed);

  { Test cloning }
  inc(result.total_tests);
  if TestClone then
    inc(result.passed)
  else
    inc(result.failed);

  { Test slicing }
  inc(result.total_tests);
  if TestSlicing then
    inc(result.passed)
  else
    inc(result.failed);

  { Test transpose }
  inc(result.total_tests);
  if TestTranspose then
    inc(result.passed)
  else
    inc(result.failed);

  { Test materialization }
  inc(result.total_tests);
  if TestMaterialization then
    inc(result.passed)
  else
    inc(result.failed);

  { Test generation tracking }
  inc(result.total_tests);
  if TestGenerationTracking then
    inc(result.passed)
  else
    inc(result.failed);

  { Test governance lemmas }
  inc(result.total_tests);
  if TestGovernanceLemmas then
    inc(result.passed)
  else
    inc(result.failed);

  { Test reference counting }
  inc(result.total_tests);
  if TestRefCounting then
    inc(result.passed)
  else
    inc(result.failed);

  { Test composite workflow }
  inc(result.total_tests);
  if TestCompositeWorkflow then
    inc(result.passed)
  else
    inc(result.failed);
end;

end.

	{ SPDX-License-Identifier: LicenseRef-Sovereign-Leviathan-SL-AGPL3-001
	Licensing: see LICENSE in the repository root. }

	{ Test Suite: Comprehensive conformance tests for NraayTensor reference implementation.
	Tests core operations, governance properties, and state machine transitions.
	}

	unit tests;

	{$MODE FPC}

	interface

	uses
	descriptor, buffer, tensor_array, ownership, governance, materialize, tensor, validation;

	type
	{ Test statistics }
	TTestStats = record
	total_tests: integer;
	passed: integer;
	failed: integer;
	end;

	{ Run all conformance tests }
	function RunAllTests: TTestStats;

	{ Test: Tensor allocation }
	function TestAllocation: boolean;

	{ Test: Element get/set }
	function TestElementAccess: boolean;

	{ Test: Clone creates shared reference }
	function TestClone: boolean;

	{ Test: Slicing creates non-contiguous view }
	function TestSlicing: boolean;

	{ Test: Transpose permutes axes }
	function TestTranspose: boolean;

	{ Test: Materialization restores contiguity }
	function TestMaterialization: boolean;

	{ Test: Generation tracking }
	function TestGenerationTracking: boolean;

	{ Test: Governance lemmas }
	function TestGovernanceLemmas: boolean;

	{ Test: Buffer reference counting }
	function TestRefCounting: boolean;

	{ Test: Composite workflow }
	function TestCompositeWorkflow: boolean;

	implementation

	var
	test_stats: TTestStats;

	function TestAllocation: boolean;
	var
	t: TNraayTensor;
	shape: array [0..1] of uint32;
	begin
	shape[0] := 3;
	shape[1] := 4;

	t := CreateTensor(shape);
	result := IsValid(t);

	if result then
	begin
	result := (Length(t) = 12) and (Rank(t) = 2);
	end;

	DestroyTensor(t);
	end;

	function TestElementAccess: boolean;
	var
	t: TNraayTensor;
	shape: array [0..1] of uint32;
	coord: array [0..1] of uint32;
	begin
	shape[0] := 2;
	shape[1] := 3;

	t := CreateTensor(shape);

	coord[0] := 1;
	coord[1] := 2;
	SetElement(t, coord, 42.0);

	result := (GetElement(t, coord) = 42.0);

	DestroyTensor(t);
	end;

	function TestClone: boolean;
	var
	t1, t2: TNraayTensor;
	shape: array [0..1] of uint32;
	begin
	shape[0] := 2;
	shape[1] := 2;

	t1 := CreateTensor(shape);
	t2 := CloneTensor(t1);

	{ Both should share same buffer }
	result := (GetDataPtr(t1.data) = GetDataPtr(t2.data));

	{ Refcount should be 2 }
	if result then
	result := (GetRefCount(t2.data) = 2);

	DestroyTensor(t1);
	DestroyTensor(t2);
	end;

	function TestSlicing: boolean;
	var
	t: TNraayTensor;
	sliced: TNraayTensor;
	shape: array [0..1] of uint32;
	ranges: array [0..1] of array of uint32;
	begin
	shape[0] := 5;
	shape[1] := 5;

	t := CreateTensor(shape);

	{ Create dummy ranges for slicing }
	setlength(ranges[0], 3);
	setlength(ranges[1], 3);
	ranges[0][0] := 1;
	ranges[0][1] := 4;
	ranges[0][2] := 1;
	ranges[1][0] := 1;
	ranges[1][1] := 4;
	ranges[1][2] := 1;

	sliced := Slice(t, ranges);

	{ Sliced should not be contiguous }
	result := (sliced.descriptor.is_contiguous = 0);

	{ Should be in SHARED state }
	if result then
	result := (sliced.descriptor.owns_storage = 0);

	DestroyTensor(t);
	DestroyTensor(sliced);
	end;

	function TestTranspose: boolean;
	var
	t: TNraayTensor;
	transposed: TNraayTensor;
	shape: array [0..1] of uint32;
	perm: array [0..1] of uint32;
	begin
	shape[0] := 3;
	shape[1] := 4;

	t := CreateTensor(shape);

	perm[0] := 1;
	perm[1] := 0;

	transposed := Transpose(t, perm);

	{ Shape should be swapped }
	result := (transposed.descriptor.shape_ptr^[0] = 4) and
	(transposed.descriptor.shape_ptr^[1] = 3);

	DestroyTensor(t);
	DestroyTensor(transposed);
	end;

	function TestMaterialization: boolean;
	var
	t: TNraayTensor;
	shape: array [0..1] of uint32;
	begin
	shape[0] := 2;
	shape[1] := 2;

	t := CreateTensor(shape);

	{ Should already be materialized }
	result := (t.descriptor.is_contiguous = 1) and
	(t.descriptor.owns_storage = 1);

	Materialize(t);

	result := result and
	(t.descriptor.is_contiguous = 1) and
	(t.descriptor.owns_storage = 1) and
	(t.descriptor.offset = 0);

	DestroyTensor(t);
	end;

	function TestGenerationTracking: boolean;
	var
	t: TNraayTensor;
	shape: array [0..0] of uint32;
	gen1, gen2: uint32;
	begin
	shape[0] := 5;

	t := CreateTensor(shape);
	gen1 := t.descriptor.generation;

	result := (gen1 >= 0);

	DestroyTensor(t);
	end;

	function TestGovernanceLemmas: boolean;
	var
	t: TNraayTensor;
	shape: array [0..1] of uint32;
	begin
	shape[0] := 2;
	shape[1] := 3;

	t := CreateTensor(shape);

	{ All lemmas should verify }
	result := VerifyGovernanceLemmas(t, t.data.buffer);

	DestroyTensor(t);
	end;

	function TestRefCounting: boolean;
	var
	t1, t2, t3: TNraayTensor;
	shape: array [0..0] of uint32;
	count: uint32;
	begin
	shape[0] := 10;

	t1 := CreateTensor(shape);
	count := GetRefCount(t1.data);
	result := (count = 1);

	t2 := CloneTensor(t1);
	count := GetRefCount(t2.data);
	result := result and (count = 2);

	t3 := CloneTensor(t2);
	count := GetRefCount(t3.data);
	result := result and (count = 3);

	DestroyTensor(t1);
	DestroyTensor(t2);
	DestroyTensor(t3);
	end;

	function TestCompositeWorkflow: boolean;
	var
	t1, t2, sliced, materialized: TNraayTensor;
	shape: array [0..1] of uint32;
	ranges: array [0..1] of array of uint32;
	coord: array [0..1] of uint32;
	begin
	shape[0] := 4;
	shape[1] := 4;

	t1 := CreateTensor(shape);
	result := IsValid(t1);

	{ Set a value }
	coord[0] := 2;
	coord[1] := 2;
	SetElement(t1, coord, 3.14);
	result := result and (GetElement(t1, coord) = 3.14);

	{ Clone }
	t2 := CloneTensor(t1);
	result := result and (GetRefCount(t2.data) = 2);

	{ Materialize }
	Materialize(t2);
	result := result and (t2.descriptor.is_contiguous = 1);

	DestroyTensor(t1);
	DestroyTensor(t2);
	end;

	function RunAllTests: TTestStats;
	begin
	with result do
	begin
	total_tests := 0;
	passed := 0;
	failed := 0;
	end;

	{ Test allocation }
	inc(result.total_tests);
	if TestAllocation then
	inc(result.passed)
	else
	inc(result.failed);

	{ Test element access }
	inc(result.total_tests);
	if TestElementAccess then
	inc(result.passed)
	else
	inc(result.failed);

	{ Test cloning }
	inc(result.total_tests);
	if TestClone then
	inc(result.passed)
	else
	inc(result.failed);

	{ Test slicing }
	inc(result.total_tests);
	if TestSlicing then
	inc(result.passed)
	else
	inc(result.failed);

	{ Test transpose }
	inc(result.total_tests);
	if TestTranspose then
	inc(result.passed)
	else
	inc(result.failed);

	{ Test materialization }
	inc(result.total_tests);
	if TestMaterialization then
	inc(result.passed)
	else
	inc(result.failed);

	{ Test generation tracking }
	inc(result.total_tests);
	if TestGenerationTracking then
	inc(result.passed)
	else
	inc(result.failed);

	{ Test governance lemmas }
	inc(result.total_tests);
	if TestGovernanceLemmas then
	inc(result.passed)
	else
	inc(result.failed);

	{ Test reference counting }
	inc(result.total_tests);
	if TestRefCounting then
	inc(result.passed)
	else
	inc(result.failed);

	{ Test composite workflow }
	inc(result.total_tests);
	if TestCompositeWorkflow then
	inc(result.passed)
	else
	inc(result.failed);
	end;

	end.