implemented of() and named() for CollectionFlagSets

node/tests/flagsets/number.test.ts

@@ -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])
+    })
+})