finished implementation of Base64BitFlagSets

node/tests/flagsets/base64.test.ts

@@ -1,15 +1,40 @@
-import { Base64BitFlagSet } from '~'
 import { describe, expect, test } from 'vitest'
 
+import { Base64BitFlagSet, createBase64BitFlagSet } from '~'
+
 describe(Base64BitFlagSet, () => {
     test('none', () => {
-        const flags = new Base64BitFlagSet()
+        const flags = createBase64BitFlagSet([])
 
         expect(flags.none()).toEqual('')
     })
 
+    test('of', () => {
+        const flags = createBase64BitFlagSet([])
+
+        expect(flags.of()).toEqual('')
+        expect(flags.of(1)).toEqual('B')
+        expect(flags.of(2, 3)).toEqual('G')
+    })
+
+    test('named', () => {
+        const flags = createBase64BitFlagSet([
+            { ordinal: 1, as: 'A' },
+            { ordinal: 2, as: 'B' },
+            { ordinal: 3, as: 'C' },
+            { ordinal: 4, as: 'D' },
+            { compose: ['A', 'B'], as: 'AB' },
+            { compose: ['A', 'C'], as: 'AC' },
+        ])
+
+        expect(flags.named()).toEqual('')
+        expect(flags.named('A')).toEqual('B')
+        expect(flags.named('AB', 'D')).toEqual('L')
+        expect(flags.named('AB', 'AC', 'B')).toEqual('H')
+    })
+
     test('union', () => {
-        const flags = new Base64BitFlagSet()
+        const flags = createBase64BitFlagSet([])
 
         expect(flags.union('', '')).toEqual('')
         expect(flags.union('A', 'A')).toEqual('')
@@ -20,7 +45,7 @@ describe(Base64BitFlagSet, () => {
     })
 
     test('difference', () => {
-        const flags = new Base64BitFlagSet()
+        const flags = createBase64BitFlagSet([])
 
         expect(flags.difference('', '')).toEqual('')
         expect(flags.difference('A', 'A')).toEqual('')
@@ -31,7 +56,7 @@ describe(Base64BitFlagSet, () => {
     })
 
     test('intersection', () => {
-        const flags = new Base64BitFlagSet()
+        const flags = createBase64BitFlagSet([])
 
         expect(flags.intersection('', '')).toEqual('')
         expect(flags.intersection('A', 'A')).toEqual('')
@@ -43,7 +68,7 @@ describe(Base64BitFlagSet, () => {
     })
 
     test('isSuperset', () => {
-        const flags = new Base64BitFlagSet()
+        const flags = createBase64BitFlagSet([])
 
         expect(flags.isSuperset('A', 'A')).toBe(true)
         expect(flags.isSuperset('D', 'A')).toBe(true)
@@ -53,8 +78,40 @@ describe(Base64BitFlagSet, () => {
         expect(flags.isSuperset('I', 'E')).toBe(false)
     })
 
+    test('hasAny', () => {
+        const flags = createBase64BitFlagSet([
+            { ordinal: 1, as: 'A' },
+            { ordinal: 2, as: 'B', requires: ['A'] },
+            { ordinal: 3, as: 'C', requires: ['A'] },
+            { ordinal: 4, as: 'D', requires: ['B', 'C'] },
+        ])
+
+        expect(flags.hasAny('P', 'A')).toBe(false)
+        expect(flags.hasAny('A', 'A')).toBe(false)
+        expect(flags.hasAny('H', 'B')).toBe(true)
+        expect(flags.hasAny('B', 'H')).toBe(true)
+        expect(flags.hasAny('F', 'M')).toBe(false)
+        expect(flags.hasAny('C', 'C')).toBe(false)
+    })
+
+    test('hasAll', () => {
+        const flags = createBase64BitFlagSet([
+            { ordinal: 1, as: 'A' },
+            { ordinal: 2, as: 'B', requires: ['A'] },
+            { ordinal: 3, as: 'C', requires: ['A'] },
+            { ordinal: 4, as: 'D', requires: ['B', 'C'] },
+        ])
+
+        expect(flags.hasAll('P', 'A')).toBe(true)
+        expect(flags.hasAll('A', 'A')).toBe(true)
+        expect(flags.hasAll('H', 'C')).toBe(true)
+        expect(flags.hasAll('G', 'C')).toBe(false)
+        expect(flags.hasAll('B', 'H')).toBe(false)
+        expect(flags.hasAll('F', 'M')).toBe(false)
+    })
+
     test('enumerate', () => {
-        const flags = new Base64BitFlagSet()
+        const flags = createBase64BitFlagSet([])
 
         expect([...flags.enumerate('A')]).toEqual([])
         expect([...flags.enumerate('B')]).toEqual([1])
@@ -64,4 +121,36 @@ describe(Base64BitFlagSet, () => {
         expect([...flags.enumerate('kB')]).toEqual([3, 6, 7])
         expect([...flags.enumerate('AAB')]).toEqual([13])
     })
+
+    test('maximum', () => {
+        const flags = createBase64BitFlagSet([
+            { ordinal: 1, as: 'A' },
+            { ordinal: 2, as: 'B', requires: ['A'] },
+            { ordinal: 3, as: 'C', requires: ['A'] },
+            { ordinal: 4, as: 'D', requires: ['B', 'C'] },
+        ])
+
+        expect(flags.maximum('A')).toEqual('')
+        expect(flags.maximum('B')).toEqual('B')
+        expect(flags.maximum('C')).toEqual('D')
+        expect(flags.maximum('D')).toEqual('D')
+        expect(flags.maximum('E')).toEqual('F')
+        expect(flags.maximum('I')).toEqual('P')
+    })
+
+    test('minimum', () => {
+        const flags = createBase64BitFlagSet([
+            { ordinal: 1, as: 'A' },
+            { ordinal: 2, as: 'B', requires: ['A'] },
+            { ordinal: 3, as: 'C', requires: ['A'] },
+            { ordinal: 4, as: 'D', requires: ['B', 'C'] },
+        ])
+
+        expect(flags.minimum('A')).toEqual('')
+        expect(flags.minimum('B')).toEqual('B')
+        expect(flags.minimum('C')).toEqual('')
+        expect(flags.minimum('D')).toEqual('D')
+        expect(flags.minimum('E')).toEqual('')
+        expect(flags.minimum('N')).toEqual('F')
+    })
 })