louisdevie/tatsuki
1
0
Fork 0
Code Issues Activity

finished implementation of BigBitFlagSets

Browse Source
This commit is contained in:
Louis Devie
2026-03-13 22:41:05 +01:00
parent dda19cdd14
commit 06e7932ac5
8 changed files with 406 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
node/tests/flagsets/bigint.test.ts
View File

@@ -1,15 +1,41 @@
import { BigBitFlagSet } from '~'
import { describe, expect, test } from 'vitest'
import { BigBitFlagSet, BitFlags, createBigBitFlagSet } from '~'
describe(BigBitFlagSet, () => {
test('none', () => {
const flags = new BigBitFlagSet()
const flags = createBigBitFlagSet([])
expect(flags.none()).toEqual(0n)
})
test('of', () => {
const flags = createBigBitFlagSet([])
expect(flags.of()).toEqual(0n)
expect(flags.of(1n)).toEqual(1n)
expect(flags.of(3n, 8n)).toEqual(11n)
expect(flags.of(3n, 5n, 2n)).toEqual(7n)
})
test('named', () => {
const flags = createBigBitFlagSet([
{ value: 1n, as: 'A' },
{ value: 2n, as: 'B' },
{ value: 4n, as: 'C' },
{ value: 8n, as: 'D' },
{ compose: ['A', 'B'], as: 'AB' },
{ compose: ['A', 'C'], as: 'AC' },
])
expect(flags.named()).toEqual(0n)
expect(flags.named('A')).toEqual(1n)
expect(flags.named('AB', 'D')).toEqual(11n)
expect(flags.named('AB', 'AC', 'B')).toEqual(7n)
})
test('union', () => {
const flags = new BigBitFlagSet()
const flags = createBigBitFlagSet([])
expect(flags.union(0n, 0n)).toEqual(0n)
expect(flags.union(1n, 0n)).toEqual(1n)
@@ -19,7 +45,7 @@ describe(BigBitFlagSet, () => {
})
test('difference', () => {
const flags = new BigBitFlagSet()
const flags = createBigBitFlagSet([])
expect(flags.difference(0n, 0n)).toEqual(0n)
expect(flags.difference(1n, 0n)).toEqual(1n)
@@ -29,7 +55,7 @@ describe(BigBitFlagSet, () => {
})
test('intersection', () => {
const flags = new BigBitFlagSet()
const flags = createBigBitFlagSet([])
expect(flags.intersection(0n, 0n)).toEqual(0n)
expect(flags.intersection(1n, 0n)).toEqual(0n)
@@ -40,7 +66,7 @@ describe(BigBitFlagSet, () => {
})
test('isSuperset', () => {
const flags = new BigBitFlagSet()
const flags = createBigBitFlagSet([])
expect(flags.isSuperset(0n, 0n)).toBe(true)
expect(flags.isSuperset(3n, 0n)).toBe(true)
@@ -50,8 +76,40 @@ describe(BigBitFlagSet, () => {
expect(flags.isSuperset(8n, 4n)).toBe(false)
})
test('hasAny', () => {
const flags = createBigBitFlagSet([
{ value: 1n, as: 'A' },
{ value: 2n, as: 'B', requires: ['A'] },
{ value: 4n, as: 'C', requires: ['A'] },
{ value: 8n, as: 'D', requires: ['B', 'C'] },
])
expect(flags.hasAny(15n, 0n)).toBe(false)
expect(flags.hasAny(0n, 0n)).toBe(false)
expect(flags.hasAny(7n, 1n)).toBe(true)
expect(flags.hasAny(1n, 7n)).toBe(true)
expect(flags.hasAny(5n, 12n)).toBe(false)
expect(flags.hasAny(2n, 2n)).toBe(false)
})
test('hasAll', () => {
const flags = createBigBitFlagSet([
{ value: 1n, as: 'A' },
{ value: 2n, as: 'B', requires: ['A'] },
{ value: 4n, as: 'C', requires: ['A'] },
{ value: 8n, as: 'D', requires: ['B', 'C'] },
])
expect(flags.hasAll(15n, 0n)).toBe(true)
expect(flags.hasAll(0n, 0n)).toBe(true)
expect(flags.hasAll(7n, 2n)).toBe(true)
expect(flags.hasAll(6n, 2n)).toBe(false)
expect(flags.hasAll(1n, 7n)).toBe(false)
expect(flags.hasAll(5n, 12n)).toBe(false)
})
test('enumerate', () => {
const flags = new BigBitFlagSet()
const flags = createBigBitFlagSet([])
expect([...flags.enumerate(0n)]).toEqual([])
expect([...flags.enumerate(1n)]).toEqual([1n])
@@ -60,4 +118,81 @@ describe(BigBitFlagSet, () => {
expect([...flags.enumerate(11n)]).toEqual([1n, 2n, 8n])
expect([...flags.enumerate(100n)]).toEqual([4n, 32n, 64n])
})
test('maximum', () => {
const flags = createBigBitFlagSet([
{ value: 1n, as: 'A' },
{ value: 2n, as: 'B', requires: ['A'] },
{ value: 4n, as: 'C', requires: ['A'] },
{ value: 8n, as: 'D', requires: ['B', 'C'] },
])
expect(flags.maximum(0n)).toEqual(0n)
expect(flags.maximum(1n)).toEqual(1n)
expect(flags.maximum(2n)).toEqual(3n)
expect(flags.maximum(3n)).toEqual(3n)
expect(flags.maximum(4n)).toEqual(5n)
expect(flags.maximum(8n)).toEqual(15n)
})
test('minimum', () => {
const flags = createBigBitFlagSet([
{ value: 1n, as: 'A' },
{ value: 2n, as: 'B', requires: ['A'] },
{ value: 4n, as: 'C', requires: ['A'] },
{ value: 8n, as: 'D', requires: ['B', 'C'] },
])
expect(flags.minimum(0n)).toEqual(0n)
expect(flags.minimum(1n)).toEqual(1n)
expect(flags.minimum(2n)).toEqual(0n)
expect(flags.minimum(3n)).toEqual(3n)
expect(flags.minimum(4n)).toEqual(0n)
expect(flags.minimum(13n)).toEqual(5n)
})
})
describe('BitFlags', () => {
test('union', () => {
expect(BitFlags.union(0n, 0n)).toEqual(0n)
expect(BitFlags.union(1n, 0n)).toEqual(1n)
expect(BitFlags.union(0n, 2n)).toEqual(2n)
expect(BitFlags.union(1n, 2n)).toEqual(3n)
expect(BitFlags.union(3n, 6n)).toEqual(7n)
})
test('difference', () => {
expect(BitFlags.difference(0n, 0n)).toEqual(0n)
expect(BitFlags.difference(1n, 0n)).toEqual(1n)
expect(BitFlags.difference(3n, 6n)).toEqual(1n)
expect(BitFlags.difference(6n, 3n)).toEqual(4n)
expect(BitFlags.difference(8n, 17n)).toEqual(8n)
})
test('intersection', () => {
expect(BitFlags.intersection(0n, 0n)).toEqual(0n)
expect(BitFlags.intersection(1n, 0n)).toEqual(0n)
expect(BitFlags.intersection(1n, 2n)).toEqual(0n)
expect(BitFlags.intersection(1n, 3n)).toEqual(1n)
expect(BitFlags.intersection(11n, 5n)).toEqual(1n)
expect(BitFlags.intersection(11n, 7n)).toEqual(3n)
})
test('isSuperset', () => {
expect(BitFlags.isSuperset(0n, 0n)).toBe(true)
expect(BitFlags.isSuperset(3n, 0n)).toBe(true)
expect(BitFlags.isSuperset(3n, 1n)).toBe(true)
expect(BitFlags.isSuperset(3n, 3n)).toBe(true)
expect(BitFlags.isSuperset(0n, 3n)).toBe(false)
expect(BitFlags.isSuperset(8n, 4n)).toBe(false)
})
test('enumerate', () => {
expect([...BitFlags.enumerate(0n)]).toEqual([])
expect([...BitFlags.enumerate(1n)]).toEqual([1n])
expect([...BitFlags.enumerate(2n)]).toEqual([2n])
expect([...BitFlags.enumerate(3n)]).toEqual([1n, 2n])
expect([...BitFlags.enumerate(11n)]).toEqual([1n, 2n, 8n])
expect([...BitFlags.enumerate(100n)]).toEqual([4n, 32n, 64n])
})
})