blake3-optimized/test-parallel.js at main · lamb356/blake3-optimized · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/**
 * Tests for parallel Bao encoding.
 */
'use strict';

const bao = require('./bao.js');
const { ParallelBaoEncoder, parallelEncode, getOptimalWorkerCount } = require('./bao-parallel.js');

let passed = 0;
let failed = 0;

async function asyncTest(name, fn) {
  try {
    await fn();
    console.log('PASS: ' + name);
    passed++;
  } catch (e) {
    console.log('FAIL: ' + name);
    console.log('  Error: ' + e.message);
    failed++;
  }
}

function assertArrayEqual(a, b, msg) {
  msg = msg || '';
  if (a.length !== b.length) {
    throw new Error(msg + 'Length mismatch: ' + a.length + ' vs ' + b.length);
  }
  for (let i = 0; i < a.length; i++) {
    if (a[i] !== b[i]) {
      throw new Error(msg + 'Mismatch at index ' + i + ': ' + a[i] + ' vs ' + b[i]);
    }
  }
}

function generateTestData(size) {
  const data = new Uint8Array(size);
  for (let i = 0; i < size; i++) {
    data[i] = (i * 7 + 13) % 256;
  }
  return data;
}

async function runTests() {
  console.log('Parallel Bao Tests');
  console.log('==================');
  console.log('');

  console.log('Detected CPU cores: ' + (getOptimalWorkerCount() + 1));
  console.log('');

  console.log('--- Basic Functionality ---');
  console.log('');

  await asyncTest('Small file (below threshold)', async () => {
    const data = generateTestData(1000);
    const result = await parallelEncode(data, { parallelThreshold: 2000 });
    const expected = bao.baoEncode(data);
    assertArrayEqual(result.encoded, expected.encoded);
    assertArrayEqual(result.hash, expected.hash);
  });

  await asyncTest('Large file combined mode', async () => {
    const data = generateTestData(100 * 1024);
    const result = await parallelEncode(data, { parallelThreshold: 10 * 1024 });
    const expected = bao.baoEncode(data);
    assertArrayEqual(result.encoded, expected.encoded, 'Encoded: ');
    assertArrayEqual(result.hash, expected.hash, 'Hash: ');
  });

  await asyncTest('Large file outboard mode', async () => {
    const data = generateTestData(100 * 1024);
    const result = await parallelEncode(data, { outboard: true, parallelThreshold: 10 * 1024 });
    const expected = bao.baoEncode(data, true);
    assertArrayEqual(result.encoded, expected.encoded, 'Encoded: ');
    assertArrayEqual(result.hash, expected.hash, 'Hash: ');
  });

  console.log('');
  console.log('--- Edge Cases ---');
  console.log('');

  await asyncTest('Empty input', async () => {
    const data = new Uint8Array(0);
    const result = await parallelEncode(data, { parallelThreshold: 1024 });
    const expected = bao.baoEncode(data);
    assertArrayEqual(result.encoded, expected.encoded);
    assertArrayEqual(result.hash, expected.hash);
  });

  await asyncTest('Single chunk', async () => {
    const data = generateTestData(1024);
    const result = await parallelEncode(data, { parallelThreshold: 512 });
    const expected = bao.baoEncode(data);
    assertArrayEqual(result.encoded, expected.encoded);
    assertArrayEqual(result.hash, expected.hash);
  });

  await asyncTest('Exactly 2 chunks', async () => {
    const data = generateTestData(2048);
    const result = await parallelEncode(data, { parallelThreshold: 1024 });
    const expected = bao.baoEncode(data);
    assertArrayEqual(result.encoded, expected.encoded);
    assertArrayEqual(result.hash, expected.hash);
  });

  console.log('');
  console.log('==================');
  console.log('Results: ' + passed + ' passed, ' + failed + ' failed');
  console.log('');

  if (failed > 0) {
    console.log('Some tests failed.');
    process.exit(1);
  } else {
    console.log('All parallel Bao tests passed!');
  }
}

runTests().catch(e => {
  console.error('Test runner error:', e);
  process.exit(1);
});