louisdevie/tatsuki
1
0
Fork 0
Code Issues Activity

implemented of() and named() for CollectionFlagSets

Browse Source
This commit is contained in:
Louis Devie
2026-03-05 13:15:19 +01:00
parent efea7ad407
commit 0a06d238de
13 changed files with 405 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
node/tests/flagsets/collection.test.ts
View File

@@ -1,19 +1,41 @@
import { CollectionFlagSet } from '~'
import { describe, expect, test } from 'vitest'
import { CollectionFlagSet, createCollectionFlagSet } from '~'
function set<T>(...values: T[]): Set<T> {
return new Set<T>(values)
}
describe(CollectionFlagSet, () => {
test('none', () => {
const flags = new CollectionFlagSet<string>()
const flags = createCollectionFlagSet<string>([])
expect(flags.none()).toEqual(set())
})
test('of', () => {
const flags = createCollectionFlagSet<string>([])
expect(flags.of()).toEqual(set())
expect(flags.of('a')).toEqual(set('a'))
expect(flags.of('x', 'y', 'z')).toEqual(set('x', 'y', 'z'))
})
test('named', () => {
const flags = createCollectionFlagSet([
{ value: 12, as: 'a' },
{ value: 45, as: 'b' },
{ value: 78, as: 'c' },
{ compose: ['a', 'b'], as: 'ab' },
])
expect(flags.named()).toEqual(set())
expect(flags.named('a')).toEqual(set(12))
expect(flags.named('ab', 'c')).toEqual(set(12, 45, 78))
})
test('union', () => {
const flags = new CollectionFlagSet<string>()
const flags = createCollectionFlagSet<string>([])
expect(flags.union(set(), set())).toEqual(set())
expect(flags.union(set('A'), set())).toEqual(set('A'))
@@ -23,7 +45,7 @@ describe(CollectionFlagSet, () => {
})
test('difference', () => {
const flags = new CollectionFlagSet<string>()
const flags = createCollectionFlagSet<string>([])
expect(flags.difference(set(), set())).toEqual(set())
expect(flags.difference(set('A'), set())).toEqual(set('A'))
@@ -33,7 +55,7 @@ describe(CollectionFlagSet, () => {
})
test('intersection', () => {
const flags = new CollectionFlagSet<string>()
const flags = createCollectionFlagSet<string>([])
expect(flags.intersection(set(), set())).toEqual(set())
expect(flags.intersection(set('A'), set())).toEqual(set())
@@ -44,7 +66,7 @@ describe(CollectionFlagSet, () => {
})
test('isSuperset', () => {
const flags = new CollectionFlagSet<string>()
const flags = createCollectionFlagSet<string>([])
expect(flags.isSuperset(set(), set())).toBe(true)
expect(flags.isSuperset(set('A', 'B'), set())).toBe(true)
@@ -55,7 +77,7 @@ describe(CollectionFlagSet, () => {
})
test('enumerate', () => {
const flags = new CollectionFlagSet<string>()
const flags = createCollectionFlagSet<string>([])
expect([...flags.enumerate(set())]).toEqual([])
expect([...flags.enumerate(set('A'))]).toEqual(['A'])

111
node/tests/flagsets/number.test.ts
View File

@@ -34,37 +34,45 @@ describe(BitFlagSet, () => {
})
test('union', () => {
expect(BitFlags.union(0, 0)).toEqual(0)
expect(BitFlags.union(1, 0)).toEqual(1)
expect(BitFlags.union(0, 2)).toEqual(2)
expect(BitFlags.union(1, 2)).toEqual(3)
expect(BitFlags.union(3, 6)).toEqual(7)
const flags = createBitFlagSet([])
expect(flags.union(0, 0)).toEqual(0)
expect(flags.union(1, 0)).toEqual(1)
expect(flags.union(0, 2)).toEqual(2)
expect(flags.union(1, 2)).toEqual(3)
expect(flags.union(3, 6)).toEqual(7)
})
test('difference', () => {
expect(BitFlags.difference(0, 0)).toEqual(0)
expect(BitFlags.difference(1, 0)).toEqual(1)
expect(BitFlags.difference(3, 6)).toEqual(1)
expect(BitFlags.difference(6, 3)).toEqual(4)
expect(BitFlags.difference(8, 17)).toEqual(8)
const flags = createBitFlagSet([])
expect(flags.difference(0, 0)).toEqual(0)
expect(flags.difference(1, 0)).toEqual(1)
expect(flags.difference(3, 6)).toEqual(1)
expect(flags.difference(6, 3)).toEqual(4)
expect(flags.difference(8, 17)).toEqual(8)
})
test('intersection', () => {
expect(BitFlags.intersection(0, 0)).toEqual(0)
expect(BitFlags.intersection(1, 0)).toEqual(0)
expect(BitFlags.intersection(1, 2)).toEqual(0)
expect(BitFlags.intersection(1, 3)).toEqual(1)
expect(BitFlags.intersection(11, 5)).toEqual(1)
expect(BitFlags.intersection(11, 7)).toEqual(3)
const flags = createBitFlagSet([])
expect(flags.intersection(0, 0)).toEqual(0)
expect(flags.intersection(1, 0)).toEqual(0)
expect(flags.intersection(1, 2)).toEqual(0)
expect(flags.intersection(1, 3)).toEqual(1)
expect(flags.intersection(11, 5)).toEqual(1)
expect(flags.intersection(11, 7)).toEqual(3)
})
test('isSuperset', () => {
expect(BitFlags.isSuperset(0, 0)).toBe(true)
expect(BitFlags.isSuperset(3, 0)).toBe(true)
expect(BitFlags.isSuperset(3, 1)).toBe(true)
expect(BitFlags.isSuperset(3, 3)).toBe(true)
expect(BitFlags.isSuperset(0, 3)).toBe(false)
expect(BitFlags.isSuperset(8, 4)).toBe(false)
const flags = createBitFlagSet([])
expect(flags.isSuperset(0, 0)).toBe(true)
expect(flags.isSuperset(3, 0)).toBe(true)
expect(flags.isSuperset(3, 1)).toBe(true)
expect(flags.isSuperset(3, 3)).toBe(true)
expect(flags.isSuperset(0, 3)).toBe(false)
expect(flags.isSuperset(8, 4)).toBe(false)
})
test('hasAny', () => {
@@ -100,12 +108,14 @@ describe(BitFlagSet, () => {
})
test('enumerate', () => {
expect([...BitFlags.enumerate(0)]).toEqual([])
expect([...BitFlags.enumerate(1)]).toEqual([1])
expect([...BitFlags.enumerate(2)]).toEqual([2])
expect([...BitFlags.enumerate(3)]).toEqual([1, 2])
expect([...BitFlags.enumerate(11)]).toEqual([1, 2, 8])
expect([...BitFlags.enumerate(100)]).toEqual([4, 32, 64])
const flags = createBitFlagSet([])
expect([...flags.enumerate(0)]).toEqual([])
expect([...flags.enumerate(1)]).toEqual([1])
expect([...flags.enumerate(2)]).toEqual([2])
expect([...flags.enumerate(3)]).toEqual([1, 2])
expect([...flags.enumerate(11)]).toEqual([1, 2, 8])
expect([...flags.enumerate(100)]).toEqual([4, 32, 64])
})
test('maximum', () => {
@@ -140,3 +150,48 @@ describe(BitFlagSet, () => {
expect(flags.minimum(13)).toEqual(5)
})
})
describe('BitFlags', () => {
test('union', () => {
expect(BitFlags.union(0, 0)).toEqual(0)
expect(BitFlags.union(1, 0)).toEqual(1)
expect(BitFlags.union(0, 2)).toEqual(2)
expect(BitFlags.union(1, 2)).toEqual(3)
expect(BitFlags.union(3, 6)).toEqual(7)
})
test('difference', () => {
expect(BitFlags.difference(0, 0)).toEqual(0)
expect(BitFlags.difference(1, 0)).toEqual(1)
expect(BitFlags.difference(3, 6)).toEqual(1)
expect(BitFlags.difference(6, 3)).toEqual(4)
expect(BitFlags.difference(8, 17)).toEqual(8)
})
test('intersection', () => {
expect(BitFlags.intersection(0, 0)).toEqual(0)
expect(BitFlags.intersection(1, 0)).toEqual(0)
expect(BitFlags.intersection(1, 2)).toEqual(0)
expect(BitFlags.intersection(1, 3)).toEqual(1)
expect(BitFlags.intersection(11, 5)).toEqual(1)
expect(BitFlags.intersection(11, 7)).toEqual(3)
})
test('isSuperset', () => {
expect(BitFlags.isSuperset(0, 0)).toBe(true)
expect(BitFlags.isSuperset(3, 0)).toBe(true)
expect(BitFlags.isSuperset(3, 1)).toBe(true)
expect(BitFlags.isSuperset(3, 3)).toBe(true)
expect(BitFlags.isSuperset(0, 3)).toBe(false)
expect(BitFlags.isSuperset(8, 4)).toBe(false)
})
test('enumerate', () => {
expect([...BitFlags.enumerate(0)]).toEqual([])
expect([...BitFlags.enumerate(1)]).toEqual([1])
expect([...BitFlags.enumerate(2)]).toEqual([2])
expect([...BitFlags.enumerate(3)]).toEqual([1, 2])
expect([...BitFlags.enumerate(11)]).toEqual([1, 2, 8])
expect([...BitFlags.enumerate(100)]).toEqual([4, 32, 64])
})
})