qiaoxinjiu/smart-management-auto-test
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update test framework: fix run_tests.py to support all test files, add auto-import-check for test files

Browse Source
This commit is contained in:
qiaoxinjiu
2026-05-09 15:11:30 +08:00
parent eb053a347f
commit eaba8328da
21739 changed files with 2236758 additions and 719 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
node_modules/tdigest/specs/digest.spec.js generated vendored Normal file
View File

@@ -0,0 +1,90 @@
var Digest = require('../tdigest').Digest;
var assert = require('better-assert');
assert.deepEqual = require('chai').assert.deepEqual;
describe('Digests in discrete mode', function(){
it('consumes same-valued points into a single point', function(){
var digest = new Digest({mode:'disc'});
var i, N = 1000;
for (i = 0 ; i < N ; i = i + 1) {
digest.push(42);
}
var points = digest.toArray();
assert.deepEqual(points, [{mean: 42, n:N}]);
});
it('handles multiple duplicates', function(){
var digest = new Digest({mode:'disc'});
var i, N = 10;
for (i = 0 ; i < N ; i++) {
digest.push(0.0);
digest.push(1.0);
digest.push(0.5);
}
assert.deepEqual(
digest.toArray(),
[{mean:0.0, n:N},
{mean:0.5, n:N},
{mean:1.0, n:N}]
);
});
});
describe('Digests in continuous mode', function(){
// these results should be the same as a plain old TDigest
//
it('compresses points and preserves bounds', function(){
var digest = new Digest({mode:'cont'});
var i, N = 100;
for (i = 0 ; i < N ; i += 1) {
digest.push(i*10);
}
assert(digest.size() === 100);
digest.delta = 0.1; // encourage merging (don't do this!)
digest.compress();
var points = digest.toArray();
assert(points.length < 100);
assert(points[0].mean === 0);
assert(points[points.length-1].mean === (N - 1) * 10);
});
it('automatically compresses during ingest', function(){
var digest = new Digest({mode:'cont'});
var i, N = 10000;
for (i = 0 ; i < N ; i += 1) {
digest.push(i*10);
}
var points = digest.toArray();
assert(digest.nreset > 1);
assert(points.length < 10000);
assert(points[0].mean === 0);
assert(points[points.length-1].mean === 99990);
});
});
describe('Digests in auto mode', function(){
it('preserves a discrete distribution', function(){
var digest = new Digest();
var i, ntimes = 1000, nvals=100;
for (i = 0 ; i < ntimes ; i++) {
for (j = 0 ; j < nvals ; j++) {
digest.push(j);
}
}
var result = digest.toArray();
for (i = 0 ; i < nvals ; i++) {
assert.deepEqual(result[i], {mean:i, n:ntimes});
}
});
it('compresses a continuous distribution', function(){
var digest = new Digest();
var i, N = 10, M=1000;
for (i = 0 ; i < N ; i++) {
for (i = 0 ; i < M ; i++) {
digest.push(Math.random());
}
}
var result = digest.toArray();
assert(result.length < digest.n);
});
});

184
node_modules/tdigest/specs/discrete.spec.js generated vendored Normal file
View File

@@ -0,0 +1,184 @@
// test the discrete distribution behavior, in which TDigest merging is
// disabled and mass is accumulated at points and reported exactly.
//
var TDigest = require('../tdigest').TDigest;
var assert = require('better-assert');
assert.deepEqual = require('chai').assert.deepEqual;
describe('discrete digests', function(){
it('consumes increasing-valued points', function(){
var tdigest = new TDigest(false);
var i, N = 100;
for (i = 0 ; i < N ; i += 1) {
tdigest.push(i*10);
}
var points = tdigest.toArray(true);
for (i = 0 ; i < N ; i += 1) {
assert(points[i].mean === i*10);
}
});
it('consumes decreasing-valued points', function(){
var tdigest = new TDigest(false);
var i, N = 100;
for (i = N - 1 ; i >= 0 ; i = i - 1) {
tdigest.push(i*10);
}
var points = tdigest.toArray(true);
for (i = 0 ; i < N ; i += 1) {
assert(points[i].mean === i*10);
}
});
it('consumes nonnumeric points', function(){
var tdigest = new TDigest(false);
tdigest.push("foo");
tdigest.push("bar");
tdigest.push("baz");
tdigest.push("foo");
tdigest.push("freen");
tdigest.push("bork");
tdigest.push("bork");
tdigest.push("bork");
tdigest.push("books");
var points = tdigest.toArray();
assert.deepEqual(points, [
{mean:"bar", n:1},
{mean:"baz", n:1},
{mean:"books", n:1},
{mean:"bork", n:3},
{mean:"foo", n:2},
{mean:"freen", n:1},
]);
});
it('consumes same-valued points into a single point', function(){
var tdigest = new TDigest(false);
var i, N = 100;
for (i = 0 ; i < N ; i = i + 1) {
tdigest.push(1000);
}
var points = tdigest.toArray();
assert.deepEqual(points, [{mean: 1000, n:N}]);
});
it('selects a run of duplicates containing the percentile', function(){
var tdigest = new TDigest(false);
tdigest.push([ 5, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3, 0, 0, 0, 0, 6, 1, 0, 6, 5, 3, 6, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0 ]);
assert(tdigest.percentile(0.5) === 0);
});
it('handles multiple duplicates', function(){
var tdigest = new TDigest(false);
var i, N = 10;
for (i = 0 ; i < N ; i++) {
tdigest.push(0.0);
tdigest.push(1.0);
tdigest.push(0.5);
}
assert.deepEqual(
tdigest.toArray(),
[{mean:0.0, n:N},
{mean:0.5, n:N},
{mean:1.0, n:N}]
);
});
});
describe('discrete percentile ranks', function(){
it('from a single point', function(){
var tdigest = new TDigest(false);
tdigest.push(0);
var x = [-0.5, 0, 0.5, 1.0, 1.5];
var q = [0, 1, 1, 1, 1];
assert.deepEqual(tdigest.p_rank(x), q);
});
it('from two points', function(){
var tdigest = new TDigest(false);
tdigest.push([0, 1]);
var x = [-0.5, 0, 0.5, 1.0, 1.5];
var q = [0, 0.5, 0.5, 1.0, 1.0];
assert.deepEqual(tdigest.p_rank(x), q);
});
it('from three points', function(){
var tdigest = new TDigest(false);
tdigest.push([-1, 0, 1] );
var x = [-1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5];
var q = [0, 1/3, 1/3, 2/3, 2/3, 1, 1];
assert.deepEqual(tdigest.p_rank(x), q);
});
it('from three points is same as from multiples of those points', function(){
var tdigest = new TDigest(false);
tdigest.push([0,1,-1]);
var x = [-1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5];
var result1 = tdigest.p_rank(x);
tdigest.push([0,1,-1]);
tdigest.push([0,1,-1]);
var result2 = tdigest.p_rank(x);
assert.deepEqual(result1, result2);
});
it('from four points away from the origin', function(){
var tdigest = new TDigest(false);
tdigest.push([10,11,12,13]);
var x = [9, 10, 11, 12, 13, 14];
var q = [0, 1/4, 2/4, 3/4, 1, 1];
assert.deepEqual(tdigest.p_rank(x), q);
});
it('from four points is same as from multiples of those points', function(){
var tdigest = new TDigest(false);
tdigest.push([10,11,12,13]);
var x = [9, 10, 11, 12, 13, 14];
var result1 = tdigest.p_rank(x);
tdigest.push([10,11,12,13]);
tdigest.push([10,11,12,13]);
var result2 = tdigest.p_rank(x);
assert.deepEqual(result1, result2);
});
it('from nonnumeric points', function(){
var tdigest = new TDigest(false);
tdigest.push("foo");
tdigest.push("bar");
tdigest.push("baz");
tdigest.push("freen");
var x = ["bar", "baz", "foo", "freen"];
var q = [1/4, 2/4, 3/4, 4/4];
assert.deepEqual(tdigest.p_rank(x), q);
});
});
describe('discrete percentiles', function(){
it('from a single point', function(){
var tdigest = new TDigest(false);
tdigest.push(0);
var p = [0, 0.5, 1.0];
var x = [0, 0, 0];
assert.deepEqual(tdigest.percentile(p), x);
});
it('from two points', function(){
var tdigest = new TDigest(false);
tdigest.push([0, 10]);
var p = [0, 1/4, 1/2, 3/4, 1];
var x = [0, 0, 0, 10, 10];
assert.deepEqual(tdigest.percentile(p), x);
});
it('from three points', function(){
var tdigest = new TDigest(false);
tdigest.push([0, 5, 10]);
var p = [0, 1/4, 1/2.9, 1/2, 2/3, 3/4, 1];
var x = [0, 0, 5, 5, 5, 10, 10];
assert.deepEqual(tdigest.percentile(p), x);
});
it('from four points away from the origin', function(){
var tdigest = new TDigest(false);
tdigest.push([10,11,12,13]);
var p = [0, 1/4, 1/2, 3/4, 1];
var x = [10, 10, 11, 12, 13];
assert.deepEqual(tdigest.percentile(p), x);
});
it('from nonnumeric points', function(){
var tdigest = new TDigest(false);
tdigest.push("foo");
tdigest.push("bar");
tdigest.push("baz");
tdigest.push("freen");
var p = [0, 1/4, 1/2, 3/4, 1];
var x = ["bar", "bar", "baz", "foo", "freen"];
assert.deepEqual(tdigest.percentile(p), x);
});
});

244
node_modules/tdigest/specs/tdigest.spec.js generated vendored Normal file
View File

@@ -0,0 +1,244 @@
var TDigest = require('../tdigest').TDigest;
var assert = require('better-assert');
assert.deepEqual = require('chai').assert.deepEqual;
describe('T-Digests in which each point becomes a centroid', function(){
it('consumes a point', function(){
var tdigest = new TDigest();
tdigest.push(0);
var points = tdigest.toArray();
assert.deepEqual(points, [{mean:0, n:1}]);
});
it('consumes two points', function(){
var tdigest = new TDigest();
tdigest.push([0,1]);
var points = tdigest.toArray();
assert.deepEqual(points, [{mean:0, n:1}, {mean:1, n:1}]);
});
it('consumes three points', function(){
var tdigest = new TDigest();
tdigest.push([0, 1, -1]);
var points = tdigest.toArray();
assert.deepEqual(points, [{mean:-1, n:1}, {mean:0, n:1}, {mean:1, n:1}]);
});
it('consumes increasing-valued points', function(){
var tdigest = new TDigest(0.001, 0); // force a new centroid for each pt
var i, N = 100;
for (i = 0 ; i < N ; i += 1) {
tdigest.push(i*10);
}
var points = tdigest.toArray();
for (i = 0 ; i < N ; i += 1) {
assert(points[i].mean === i*10);
}
});
it('consumes decreasing-valued points', function(){
var tdigest = new TDigest(0.001, 0); // force a new centroid for each pt
var i, N = 100;
for (i = N - 1 ; i >= 0 ; i = i - 1) {
tdigest.push(i*10);
}
var points = tdigest.toArray();
for (i = 0 ; i < N ; i += 1) {
assert(points[i].mean === i*10);
}
});
});
describe('T-Digests in which points are merged into centroids', function(){
it('consumes same-valued points into a single point', function(){
var tdigest = new TDigest();
var i, N = 100;
for (i = 0 ; i < N ; i = i + 1) {
tdigest.push(1000);
}
var points = tdigest.toArray();
assert.deepEqual(points, [{mean: 1000, n:N}]);
});
it('handles multiple duplicates', function(){
var tdigest = new TDigest(1,0,0);
var i, N = 10;
for (i = 0 ; i < N ; i++) {
tdigest.push(0.0);
tdigest.push(1.0);
tdigest.push(0.5);
}
assert.deepEqual(
tdigest.toArray(),
[{mean:0.0, n:N},
{mean:0.5, n:N},
{mean:1.0, n:N}]
);
});
});
describe('compress', function(){
it('compresses points and preserves bounds', function(){
var tdigest = new TDigest(0.001, 0);
var i, N = 100;
for (i = 0 ; i < N ; i += 1) {
tdigest.push(i*10);
}
assert(tdigest.size() === 100);
tdigest.delta = 0.1; // encourage merging (don't do this!)
tdigest.compress();
var points = tdigest.toArray();
assert(points.length < 100);
assert(points[0].mean === 0);
assert(points[points.length-1].mean === (N - 1) * 10);
});
it('K automatically compresses during ingest', function(){
var tdigest = new TDigest();
var i, N = 10000;
for (i = 0 ; i < N ; i += 1) {
tdigest.push(i*10);
}
var points = tdigest.toArray();
assert(tdigest.nreset > 1);
assert(points.length < 10000);
assert(points[0].mean === 0);
assert(points[points.length-1].mean === 99990);
});
});
describe('percentile ranks', function(){
//
// TDigests are really meant for large datasets and continuous
// distributions. On small or categorical sets, results can seem
// strange because mass exists at boundary points. The small tests
// here verify some precise behaviors that may not be relevant at
// scale.
//
it('reports undefined when given no points', function(){
var tdigest = new TDigest();
var x = [1, 2, 3];
assert.deepEqual(tdigest.p_rank(1), undefined);
assert.deepEqual(tdigest.p_rank(x), [undefined,undefined,undefined]);
});
it('from a single point', function(){
var tdigest = new TDigest();
tdigest.push(0);
var x = [-0.5, 0, 0.5, 1.0, 1.5];
var q = [0, 0.5, 1, 1, 1];
assert.deepEqual(tdigest.p_rank(x), q);
});
it('from two points', function(){
var tdigest = new TDigest();
tdigest.push([0, 1]);
var x = [-0.5, 0, 0.5, 1.0, 1.5];
var q = [0, 0.25, 0.5, 0.75, 1];
assert.deepEqual(tdigest.p_rank(x), q);
});
it('from three points', function(){
var tdigest = new TDigest();
tdigest.push([-1, 0, 1] );
var x = [-1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5];
var q = [0, 1/6, 2/6, 3/6, 4/6, 5/6, 1];
assert.deepEqual(tdigest.p_rank(x), q);
});
it('from three points is same as from multiples of those points', function(){
var tdigest = new TDigest();
tdigest.push([0,1,-1]);
var x = [-1.5, -1.0, -0.5, 0, 0.5, 1.0, 1.5];
var result1 = tdigest.p_rank(x);
tdigest.push([0,1,-1]);
tdigest.push([0,1,-1]);
var result2 = tdigest.p_rank(x);
assert.deepEqual(result1, result2);
});
it('from four points away from the origin', function(){
var tdigest = new TDigest();
tdigest.push([10,11,12,13]);
var x = [9, 10, 11, 12, 13, 14];
var q = [0, 1/8, 3/8, 5/8, 7/8, 1];
assert.deepEqual(tdigest.p_rank(x), q);
});
it('from four points is same as from multiples of those points', function(){
var tdigest = new TDigest(0, 0);
tdigest.push([10,11,12,13]);
var x = [9, 10, 11, 12, 13, 14];
var result1 = tdigest.p_rank(x);
tdigest.push([10,11,12,13]);
tdigest.push([10,11,12,13]);
var result2 = tdigest.p_rank(x);
assert.deepEqual(result1, result2);
});
it('from lots of uniformly distributed points', function(){
var tdigest = new TDigest();
var i, x=[], N = 100000;
var maxerr = 0;
for (i = 0 ; i < N ; i += 1) {
x.push(Math.random());
}
tdigest.push(x);
tdigest.compress();
for (i = 0.01 ; i <= 1 ; i += 0.01) {
var q = tdigest.p_rank(i);
maxerr = Math.max(maxerr, Math.abs(i-q));
}
assert(maxerr < 0.01);
});
it('from an exact match', function(){
var tdigest = new TDigest(0.001,0); // no compression
var i, N = 10;
var maxerr = 0;
for (i = 0 ; i < N ; i += 1) {
tdigest.push([10, 20, 30]);
}
assert(tdigest.p_rank(20) === 0.5);
});
});
describe('percentiles', function(){
it('reports undefined when given no points', function(){
var tdigest = new TDigest();
var p = [0, 0.5, 1.0];
assert.deepEqual(tdigest.percentile(0.5), undefined);
assert.deepEqual(tdigest.percentile(p), [undefined,undefined,undefined]);
});
it('from a single point', function(){
var tdigest = new TDigest();
tdigest.push(0);
var p = [0, 0.5, 1.0];
var x = [0, 0, 0];
assert.deepEqual(tdigest.percentile(p), x);
});
it('from two points', function(){
var tdigest = new TDigest();
tdigest.push([0, 1]);
var p = [-1/4, 0, 1/4, 1/2, 5/8, 3/4, 1, 1.25];
var x = [ 0, 0, 0, 0.5, 0.75, 1, 1, 1];
assert.deepEqual(tdigest.percentile(p), x);
});
it('from three points', function(){
var tdigest = new TDigest();
tdigest.push([0, 0.5, 1]);
var p = [0, 1/4, 1/2, 3/4, 1];
var x = [0, 0.125, 0.5, 0.875, 1.0];
assert.deepEqual(tdigest.percentile(p), x);
});
it('from four points', function(){
var tdigest = new TDigest();
tdigest.push([10, 11, 12, 13]);
var p = [0, 1/4, 1/2, 3/4, 1];
var x = [10.0, 10.5, 11.5, 12.5, 13.0];
assert.deepEqual(tdigest.percentile(p), x);
});
it('from lots of uniformly distributed points', function(){
var tdigest = new TDigest();
var i, x=[], N = 100000;
var maxerr = 0;
for (i = 0 ; i < N ; i += 1) {
x.push(Math.random());
}
tdigest.push(x);
tdigest.compress();
for (i = 0.01 ; i <= 1 ; i += 0.01) {
var q = tdigest.percentile(i);
maxerr = Math.max(maxerr, Math.abs(i-q));
}
assert(maxerr < 0.01);
});
});