297 lines
8.7 KiB
Dart
297 lines
8.7 KiB
Dart
// Copyright (c) 2024, Sudipto Chandra
|
|
// All rights reserved. Check LICENSE file for details.
|
|
|
|
import 'dart:isolate';
|
|
import 'dart:typed_data';
|
|
|
|
import 'package:hashlib/codecs.dart';
|
|
import 'package:hashlib/src/uuid.dart';
|
|
import 'package:test/test.dart';
|
|
|
|
@pragma('vm:entry-point')
|
|
void runIsolate(dynamic inp) {
|
|
final port = inp[0] as SendPort;
|
|
switch (inp[1] as String) {
|
|
case 'v1':
|
|
return port.send(uuid.v1());
|
|
case 'v3':
|
|
return port.send(uuid.v3());
|
|
case 'v4':
|
|
return port.send(uuid.v4());
|
|
case 'v5':
|
|
return port.send(uuid.v5());
|
|
case 'v6':
|
|
return port.send(uuid.v6());
|
|
case 'v7':
|
|
return port.send(uuid.v7());
|
|
case 'v8':
|
|
return port.send(uuid.v8());
|
|
}
|
|
throw ArgumentError('Undefined version');
|
|
}
|
|
|
|
void main() {
|
|
group('UUID v1', () {
|
|
test("known value", () {
|
|
final time = DateTime.parse('2022-02-22T14:22:22-0500').toUtc();
|
|
final clockSeq = 0x33C8;
|
|
final node = 0x9F6BDECED846;
|
|
final out = 'c232ab00-9414-11ec-b3c8-9f6bdeced846';
|
|
final res = uuid.v1(node: node, clockSeq: clockSeq, utc: time);
|
|
expect(res, equals(out));
|
|
});
|
|
test('uniqueness with futures', () async {
|
|
final seeds = await Future.wait(List.generate(
|
|
1000,
|
|
(_) => Future.microtask(uuid.v1),
|
|
));
|
|
expect(seeds.toSet().length, 1000);
|
|
});
|
|
|
|
test('uniqueness with isolates', () async {
|
|
final receiver = ReceivePort();
|
|
await Future.wait(List.generate(
|
|
100,
|
|
(_) => Isolate.spawn(
|
|
runIsolate,
|
|
[receiver.sendPort, 'v1'],
|
|
errorsAreFatal: true,
|
|
),
|
|
));
|
|
final items = await receiver.take(100).toList();
|
|
expect(items.toSet().length, 100);
|
|
}, tags: ['vm-only'], timeout: Timeout(Duration(minutes: 5)));
|
|
});
|
|
|
|
group('UUID v3', () {
|
|
test("known value", () {
|
|
final namespace = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
|
|
final name = 'www.example.com';
|
|
final out = '5df41881-3aed-3515-88a7-2f4a814cf09e';
|
|
final res = uuid.v3(name: name, namespace: namespace);
|
|
expect(res, equals(out));
|
|
});
|
|
test('uniqueness with futures', () async {
|
|
final seeds = await Future.wait(List.generate(
|
|
1000,
|
|
(_) => Future.microtask(uuid.v3),
|
|
));
|
|
expect(seeds.toSet().length, 1000);
|
|
});
|
|
|
|
test('uniqueness with isolates', () async {
|
|
final receiver = ReceivePort();
|
|
await Future.wait(List.generate(
|
|
100,
|
|
(_) => Isolate.spawn(
|
|
runIsolate,
|
|
[receiver.sendPort, 'v3'],
|
|
errorsAreFatal: true,
|
|
),
|
|
));
|
|
final items = await receiver.take(100).toList();
|
|
expect(items.toSet().length, 100);
|
|
}, tags: ['vm-only'], timeout: Timeout(Duration(minutes: 5)));
|
|
});
|
|
|
|
group('UUID v4', () {
|
|
test("known value", () {
|
|
final out = RegExp(r'........-....-4...-....-............');
|
|
final res = uuid.v4();
|
|
expect(res, matches(out));
|
|
final part4 = fromHex(res.split('-')[3]).buffer.asUint8List();
|
|
expect(part4[0] >>> 6, 2);
|
|
});
|
|
test('uniqueness with futures', () async {
|
|
final seeds = await Future.wait(List.generate(
|
|
1000,
|
|
(_) => Future.microtask(uuid.v4),
|
|
));
|
|
expect(seeds.toSet().length, 1000);
|
|
});
|
|
|
|
test('uniqueness with isolates', () async {
|
|
final receiver = ReceivePort();
|
|
await Future.wait(List.generate(
|
|
100,
|
|
(_) => Isolate.spawn(
|
|
runIsolate,
|
|
[receiver.sendPort, 'v4'],
|
|
errorsAreFatal: true,
|
|
),
|
|
));
|
|
final items = await receiver.take(100).toList();
|
|
expect(items.toSet().length, 100);
|
|
}, tags: ['vm-only'], timeout: Timeout(Duration(minutes: 5)));
|
|
});
|
|
|
|
group('UUID v5', () {
|
|
test("known value", () {
|
|
final namespace = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
|
|
final name = 'www.example.com';
|
|
final out = '2ed6657d-e927-568b-95e1-2665a8aea6a2';
|
|
final res = uuid.v5(name: name, namespace: namespace);
|
|
expect(res, equals(out));
|
|
});
|
|
test('uniqueness with futures', () async {
|
|
final seeds = await Future.wait(List.generate(
|
|
1000,
|
|
(_) => Future.microtask(uuid.v5),
|
|
));
|
|
expect(seeds.toSet().length, 1000);
|
|
});
|
|
|
|
test('uniqueness with isolates', () async {
|
|
final receiver = ReceivePort();
|
|
await Future.wait(List.generate(
|
|
100,
|
|
(_) => Isolate.spawn(
|
|
runIsolate,
|
|
[receiver.sendPort, 'v5'],
|
|
errorsAreFatal: true,
|
|
),
|
|
));
|
|
final items = await receiver.take(100).toList();
|
|
expect(items.toSet().length, 100);
|
|
}, tags: ['vm-only'], timeout: Timeout(Duration(minutes: 5)));
|
|
});
|
|
|
|
group('UUID v6', () {
|
|
test("known value", () {
|
|
final time = DateTime.parse('2022-02-22T14:22:22-0500').toUtc();
|
|
final clockSeq = 0x33C8;
|
|
final node = 0x9F6BDECED846;
|
|
final out = '1ec9414c-232a-6b00-b3c8-9f6bdeced846';
|
|
final res = uuid.v6(node: node, clockSeq: clockSeq, utc: time);
|
|
expect(res, equals(out));
|
|
});
|
|
test('uniqueness with futures', () async {
|
|
final seeds = await Future.wait(List.generate(
|
|
1000,
|
|
(_) => Future.microtask(uuid.v6),
|
|
));
|
|
expect(seeds.toSet().length, 1000);
|
|
});
|
|
|
|
test('uniqueness with isolates', () async {
|
|
final receiver = ReceivePort();
|
|
await Future.wait(List.generate(
|
|
100,
|
|
(_) => Isolate.spawn(
|
|
runIsolate,
|
|
[receiver.sendPort, 'v6'],
|
|
errorsAreFatal: true,
|
|
),
|
|
));
|
|
final items = await receiver.take(100).toList();
|
|
expect(items.toSet().length, 100);
|
|
}, tags: ['vm-only'], timeout: Timeout(Duration(minutes: 5)));
|
|
});
|
|
|
|
group('UUID v7', () {
|
|
test("known value", () {
|
|
final time = DateTime.parse('2022-02-22T14:22:22-0500').toUtc();
|
|
final out = RegExp(r'017f22e2-79b0-7...-....-............');
|
|
final res = uuid.v7(utc: time);
|
|
expect(res, matches(out));
|
|
final part4 = fromHex(res.split('-')[3]).buffer.asUint8List();
|
|
expect(part4[0] >>> 6, 2);
|
|
});
|
|
test('uniqueness with futures', () async {
|
|
final seeds = await Future.wait(List.generate(
|
|
1000,
|
|
(_) => Future.microtask(uuid.v7),
|
|
));
|
|
expect(seeds.toSet().length, 1000);
|
|
});
|
|
|
|
test('uniqueness with isolates', () async {
|
|
final receiver = ReceivePort();
|
|
await Future.wait(List.generate(
|
|
100,
|
|
(_) => Isolate.spawn(
|
|
runIsolate,
|
|
[receiver.sendPort, 'v7'],
|
|
errorsAreFatal: true,
|
|
),
|
|
));
|
|
final items = await receiver.take(100).toList();
|
|
expect(items.toSet().length, 100);
|
|
}, tags: ['vm-only'], timeout: Timeout(Duration(minutes: 5)));
|
|
});
|
|
|
|
group('UUID v8', () {
|
|
test("known value 1", () {
|
|
final nonce = fromHex('2489E9AD2EE20E000EC932D5F69181C0');
|
|
final out = '2489e9ad-2ee2-8e00-8ec9-32d5f69181c0';
|
|
final res = uuid.v8(nonce: nonce);
|
|
expect(res, equals(out));
|
|
});
|
|
test("known value 2", () {
|
|
final nonce = fromHex('5c146b143c524afd938a375d0df1fbf6');
|
|
final out = '5c146b14-3c52-8afd-938a-375d0df1fbf6';
|
|
final res = uuid.v8(nonce: nonce);
|
|
expect(res, equals(out));
|
|
});
|
|
test("throws argument error on invalid nonce", () {
|
|
for (int i = 0; i < 20; ++i) {
|
|
final nonce = Uint8List(i);
|
|
if (i == 16) {
|
|
uuid.v8(nonce: nonce);
|
|
} else {
|
|
expect(
|
|
() => uuid.v8(nonce: nonce),
|
|
throwsArgumentError,
|
|
reason: 'length: $i',
|
|
);
|
|
}
|
|
}
|
|
});
|
|
test('uniqueness with futures', () async {
|
|
final seeds = await Future.wait(List.generate(
|
|
1000,
|
|
(_) => Future.microtask(uuid.v8),
|
|
));
|
|
expect(seeds.toSet().length, 1000);
|
|
});
|
|
|
|
test('uniqueness with isolates', () async {
|
|
final receiver = ReceivePort();
|
|
await Future.wait(List.generate(
|
|
100,
|
|
(_) => Isolate.spawn(
|
|
runIsolate,
|
|
[receiver.sendPort, 'v8'],
|
|
errorsAreFatal: true,
|
|
),
|
|
));
|
|
final items = await receiver.take(100).toList();
|
|
expect(items.toSet().length, 100);
|
|
}, tags: ['vm-only'], timeout: Timeout(Duration(minutes: 5)));
|
|
});
|
|
|
|
group('NamespaceValue', () {
|
|
final matcher = matches('........-....-....-....-............');
|
|
test('dns', () {
|
|
expect(Namespace.dns.value, matcher);
|
|
});
|
|
test('url', () {
|
|
expect(Namespace.url.value, matcher);
|
|
});
|
|
test('oid', () {
|
|
expect(Namespace.oid.value, matcher);
|
|
});
|
|
test('x500', () {
|
|
expect(Namespace.x500.value, matcher);
|
|
});
|
|
test('nil', () {
|
|
expect(Namespace.nil.value, matcher);
|
|
});
|
|
test('max', () {
|
|
expect(Namespace.max.value, matcher);
|
|
});
|
|
test('time', () {
|
|
expect(Namespace.time, matcher);
|
|
});
|
|
});
|
|
}
|