WIP: shifted indexes of string array wrappers #1

test/dev/dev.ts

@@ -20,6 +20,8 @@ import { StringArrayWrappersType } from '../../src/enums/node-transformers/strin
                 console.log(arg, hawk, eagle);
             }
             
+            console.log(foo, bar, baz);
+            
             test();
         `,
         {

test/unit-tests/storages/ArrayStorage.spec.ts

@@ -245,6 +245,81 @@ describe('ArrayStorage', () => {
         });
     });
 
+    describe('delete', () => {
+        describe('Variant #1: value exist', () => {
+            const expectedUpdatedStorage: string[] = [
+                'foo',
+                'baz'
+            ];
+            const expectedUpdatedStorageLength: number = 2;
+            const expectedDeletedValue: string = 'bar';
+
+            let updatedStorage: string[];
+            let updatedStorageLength: number;
+            let deletedValue: string;
+
+            before(() => {
+                storage = getStorageInstance<string>();
+                storage.set(0, 'foo');
+                storage.set(1, 'bar');
+                storage.set(2, 'baz');
+
+                deletedValue = storage.delete(1);
+                updatedStorage = storage.getStorage();
+                updatedStorageLength = storage.getLength();
+            });
+
+            it('should delete value from the storage by index', () => {
+                assert.deepEqual(updatedStorage, expectedUpdatedStorage);
+            });
+
+            it('should update storage length', () => {
+                assert.deepEqual(updatedStorageLength, expectedUpdatedStorageLength);
+            });
+
+            it('should return deleted value', () => {
+                assert.equal(deletedValue, expectedDeletedValue);
+            });
+        });
+
+        describe('Variant #2: value isn\'t exist', () => {
+            const expectedUpdatedStorage: string[] = [
+                'foo',
+                'bar',
+                'baz'
+            ];
+            const expectedUpdatedStorageLength: number = 3;
+            const expectedDeletedValue: undefined = undefined;
+
+            let updatedStorage: string[];
+            let updatedStorageLength: number;
+            let deletedValue: string;
+
+            before(() => {
+                storage = getStorageInstance<string>();
+                storage.set(0, 'foo');
+                storage.set(1, 'bar');
+                storage.set(2, 'baz');
+
+                deletedValue = storage.delete(3);
+                updatedStorage = storage.getStorage();
+                updatedStorageLength = storage.getLength();
+            });
+
+            it('should keep storage the same', () => {
+                assert.deepEqual(updatedStorage, expectedUpdatedStorage);
+            });
+
+            it('should keep storage length', () => {
+                assert.deepEqual(updatedStorageLength, expectedUpdatedStorageLength);
+            });
+
+            it('should return undefined', () => {
+                assert.equal(deletedValue, expectedDeletedValue);
+            });
+        });
+    });
+
     describe('mergeWith', () => {
         describe('Base merge', () => {
             const secondStorageKey: number = 1;

test/unit-tests/storages/string-array-transformers/visited-lexical-scope-nodes-stack/VisitedLexicalScopeNodesStackStorage.spec.ts

@@ -67,6 +67,79 @@ describe('VisitedLexicalScopeNodesStackStorage', () => {
         });
     });
 
+    describe('getPenultimateElement', () => {
+        describe('Variant #1: three array elements', () => {
+            const firstElement: TNodeWithLexicalScopeStatements = NodeFactory.blockStatementNode([
+                NodeFactory.expressionStatementNode(
+                    NodeFactory.literalNode('first')
+                )
+            ]);
+            const expectedSecondElement: TNodeWithLexicalScopeStatements = NodeFactory.blockStatementNode([
+                NodeFactory.expressionStatementNode(
+                    NodeFactory.literalNode('second')
+                )
+            ]);
+            const lastElement: TNodeWithLexicalScopeStatements =  NodeFactory.blockStatementNode([
+                NodeFactory.expressionStatementNode(
+                    NodeFactory.literalNode('last')
+                )
+            ]);
+
+            let penultimateElement: TNodeWithLexicalScopeStatements | undefined;
+
+            before(() => {
+                const visitedLexicalScopeNodesStackStorage: IVisitedLexicalScopeNodesStackStorage = getStorageInstance();
+
+                visitedLexicalScopeNodesStackStorage.push(firstElement);
+                visitedLexicalScopeNodesStackStorage.push(expectedSecondElement);
+                visitedLexicalScopeNodesStackStorage.push(lastElement);
+                penultimateElement = visitedLexicalScopeNodesStackStorage.getPenultimateElement();
+            });
+
+            it('should return a penultimate element from the stack', () => {
+                assert.equal(penultimateElement, expectedSecondElement);
+            });
+        });
+
+        describe('Variant #2: one array element', () => {
+            const expectedPenultimateElement: undefined = undefined;
+            const firstElement: TNodeWithLexicalScopeStatements = NodeFactory.blockStatementNode([
+                NodeFactory.expressionStatementNode(
+                    NodeFactory.literalNode('first')
+                )
+            ]);
+
+            let penultimateElement: TNodeWithLexicalScopeStatements | undefined;
+
+            before(() => {
+                const visitedLexicalScopeNodesStackStorage: IVisitedLexicalScopeNodesStackStorage = getStorageInstance();
+
+                visitedLexicalScopeNodesStackStorage.push(firstElement);
+                penultimateElement = visitedLexicalScopeNodesStackStorage.getPenultimateElement();
+            });
+
+            it('should return a penultimate element from the stack', () => {
+                assert.equal(penultimateElement, expectedPenultimateElement);
+            });
+        });
+
+        describe('Variant #3: empty array', () => {
+            const expectedPenultimateElement: undefined = undefined;
+
+            let penultimateElement: TNodeWithLexicalScopeStatements | undefined;
+
+            before(() => {
+                const visitedLexicalScopeNodesStackStorage: IVisitedLexicalScopeNodesStackStorage = getStorageInstance();
+
+                penultimateElement = visitedLexicalScopeNodesStackStorage.getPenultimateElement();
+            });
+
+            it('should return a penultimate element from the stack', () => {
+                assert.equal(penultimateElement, expectedPenultimateElement);
+            });
+        });
+    });
+
     describe('push', () => {
         const firstElement: TNodeWithLexicalScopeStatements = NodeFactory.blockStatementNode([
             NodeFactory.expressionStatementNode(
@@ -99,40 +172,72 @@ describe('VisitedLexicalScopeNodesStackStorage', () => {
     });
 
     describe('pop', () => {
-        const firstElement: TNodeWithLexicalScopeStatements = NodeFactory.blockStatementNode([
-            NodeFactory.expressionStatementNode(
-                NodeFactory.literalNode('first')
-            )
-        ]);
-        const secondElement: TNodeWithLexicalScopeStatements = NodeFactory.blockStatementNode([
-            NodeFactory.expressionStatementNode(
-                NodeFactory.literalNode('second')
-            )
-        ]);
-        const expectedStorage: TNodeWithLexicalScopeStatements[] = [
-            firstElement
-        ];
-        const expectedPoppedElement: TNodeWithLexicalScopeStatements = secondElement;
+        describe('Variant #1: few elements', () => {
+            const firstElement: TNodeWithLexicalScopeStatements = NodeFactory.blockStatementNode([
+                NodeFactory.expressionStatementNode(
+                    NodeFactory.literalNode('first')
+                )
+            ]);
+            const secondElement: TNodeWithLexicalScopeStatements = NodeFactory.blockStatementNode([
+                NodeFactory.expressionStatementNode(
+                    NodeFactory.literalNode('second')
+                )
+            ]);
+            const expectedStorage: TNodeWithLexicalScopeStatements[] = [
+                firstElement
+            ];
+            const expectedPoppedElement: TNodeWithLexicalScopeStatements = secondElement;
 
-        let storage: TNodeWithLexicalScopeStatements[];
-        let poppedElement: TNodeWithLexicalScopeStatements | undefined;
+            let storage: TNodeWithLexicalScopeStatements[];
+            let poppedElement: TNodeWithLexicalScopeStatements | undefined;
 
-        before(() => {
-            const visitedLexicalScopeNodesStackStorage: IVisitedLexicalScopeNodesStackStorage = getStorageInstance();
+            before(() => {
+                const visitedLexicalScopeNodesStackStorage: IVisitedLexicalScopeNodesStackStorage = getStorageInstance();
 
-            visitedLexicalScopeNodesStackStorage.push(firstElement);
-            visitedLexicalScopeNodesStackStorage.push(secondElement);
+                visitedLexicalScopeNodesStackStorage.push(firstElement);
+                visitedLexicalScopeNodesStackStorage.push(secondElement);
 
-            poppedElement = visitedLexicalScopeNodesStackStorage.pop();
-            storage = visitedLexicalScopeNodesStackStorage.getStorage();
+                poppedElement = visitedLexicalScopeNodesStackStorage.pop();
+                storage = visitedLexicalScopeNodesStackStorage.getStorage();
+            });
+
+            it('should pop a last element from the storage', () => {
+                assert.deepEqual(storage, expectedStorage);
+            });
+
+            it('should return a popped element from the storage', () => {
+                assert.equal(poppedElement, expectedPoppedElement);
+            });
         });
 
-        it('should pop a last element from the storage', () => {
-            assert.deepEqual(storage, expectedStorage);
-        });
+        describe('Variant #2: single element', () => {
+            const firstElement: TNodeWithLexicalScopeStatements = NodeFactory.blockStatementNode([
+                NodeFactory.expressionStatementNode(
+                    NodeFactory.literalNode('first')
+                )
+            ]);
+            const expectedStorage: TNodeWithLexicalScopeStatements[] = [];
+            const expectedPoppedElement: TNodeWithLexicalScopeStatements = firstElement;
 
-        it('should return a popped element from the storage', () => {
-            assert.equal(poppedElement, expectedPoppedElement);
+            let storage: TNodeWithLexicalScopeStatements[];
+            let poppedElement: TNodeWithLexicalScopeStatements | undefined;
+
+            before(() => {
+                const visitedLexicalScopeNodesStackStorage: IVisitedLexicalScopeNodesStackStorage = getStorageInstance();
+
+                visitedLexicalScopeNodesStackStorage.push(firstElement);
+
+                poppedElement = visitedLexicalScopeNodesStackStorage.pop();
+                storage = visitedLexicalScopeNodesStackStorage.getStorage();
+            });
+
+            it('should pop a last element from the storage', () => {
+                assert.deepEqual(storage, expectedStorage);
+            });
+
+            it('should return a popped element from the storage', () => {
+                assert.equal(poppedElement, expectedPoppedElement);
+            });
         });
     });
 });