feat: added performance test for 2618

Author: shahadathhs

prettier.config.mjs

@@ -2,7 +2,7 @@ export default {
   singleQuote: true,
   trailingComma: 'all',
   tabWidth: 2,
-  semi: false,
+  semi: true,
   printWidth: 100,
   bracketSpacing: true,
   arrowParens: 'avoid',

src/__tests__/2618-check-if-object-instance-of-class.test.ts

@@ -1,13 +1,14 @@
 import {
   checkIfInstanceOf,
   checkIfInstanceOfUsingPrototype,
-} from '@/app/2618-check-if-object-instance-of-class'
+  InstanceOfFunction,
+} from '@/app/2618-check-if-object-instance-of-class';
 
 describe('Problem 2618: Check If Instance Of Class', () => {
   const testCases: {
-    name: string
-    input: [any, any]
-    expected: boolean
+    name: string;
+    input: [any, any];
+    expected: boolean;
   }[] = [
     {
       name: 'Example 1: new Date() is an instance of Date',
@@ -19,7 +20,7 @@ describe('Problem 2618: Check If Instance Of Class', () => {
       input: (() => {
         class Animal {}
         class Dog extends Animal {}
-        return [new Dog(), Animal] as [any, any]
+        return [new Dog(), Animal] as [any, any];
       })(),
       expected: true,
     },
@@ -43,16 +44,69 @@ describe('Problem 2618: Check If Instance Of Class', () => {
       input: [new Number(5), undefined],
       expected: false,
     },
-  ]
+  ];
 
+  // ✅ Correctness Tests
   describe.each([
     ['🔍 instanceof version', checkIfInstanceOf],
     ['🔁 prototype-traversal version', checkIfInstanceOfUsingPrototype],
-  ])('%s', (_label, fn) => {
+  ])('%s - Correctness', (_label, fn) => {
     testCases.forEach(({ name, input, expected }) => {
       test(name, () => {
-        expect(fn(...input)).toBe(expected)
-      })
-    })
-  })
-})
+        expect(fn(...input)).toBe(expected);
+      });
+    });
+  });
+
+  // ✅ Dynamic Fuzzing
+  describe.each([
+    ['🔍 instanceof version', checkIfInstanceOf],
+    ['🔁 prototype-traversal version', checkIfInstanceOfUsingPrototype],
+  ])('%s - Dynamic Fuzzing', (_label, fn) => {
+    const constructors = [
+      Date,
+      Number,
+      String,
+      Boolean,
+      Object,
+      Array,
+      Map,
+      Set,
+      WeakMap,
+      WeakSet,
+      RegExp,
+      Error,
+    ];
+
+    test('Run 500 random fuzzing tests', () => {
+      for (let i = 0; i < 500; i++) {
+        const randomClass = constructors[Math.floor(Math.random() * constructors.length)];
+        const instance = new (randomClass as any)();
+        const expected = instance instanceof randomClass;
+        const result = fn(instance, randomClass);
+        expect(result).toBe(expected);
+      }
+    });
+  });
+
+  // ✅ Benchmarking
+  describe('🚀 Benchmarking Performance', () => {
+    const iterations = 100_000;
+    const Dog = class extends Object {};
+    const input: [any, any] = [new Dog(), Object];
+
+    const benchmark = (label: string, fn: InstanceOfFunction) => {
+      const start = performance.now();
+      for (let i = 0; i < iterations; i++) {
+        fn(...input);
+      }
+      const end = performance.now();
+      console.log(`${label} took ${(end - start).toFixed(2)}ms for ${iterations} iterations`);
+    };
+
+    test('Compare performance', () => {
+      benchmark('checkIfInstanceOf', checkIfInstanceOf);
+      benchmark('checkIfInstanceOfUsingPrototype', checkIfInstanceOfUsingPrototype);
+    });
+  });
+});

src/app/2618-check-if-object-instance-of-class.ts

@@ -28,53 +28,55 @@
 //   https://leetcode.com/problems/check-if-object-instance-of-class/description
 
 // * Solution
+export type InstanceOfFunction = (obj: any, classFunction: any) => boolean;
+
 function checkIfInstanceOf(obj: any, classFunction: any): boolean {
   // If obj is null or undefined, it can't be an instance of anything
-  if (obj === null || obj === undefined) return false
+  if (obj === null || obj === undefined) return false;
 
   // If classFunction is not a function (i.e., not a constructor), return false
-  if (typeof classFunction !== 'function') return false
+  if (typeof classFunction !== 'function') return false;
 
   // If the object is already an instance of the class, return true
-  if (obj instanceof classFunction) return true
+  if (obj instanceof classFunction) return true;
 
   // Try converting the value to an object and check again using instanceof
   // This handles edge cases like primitives (e.g., number, string)
   try {
-    return Object(obj) instanceof classFunction
+    return Object(obj) instanceof classFunction;
   } catch {
     // If conversion or check fails (e.g., invalid input), return false
-    return false
+    return false;
   }
 }
 
 function checkIfInstanceOfUsingPrototype(obj: any, classFunction: any): boolean {
   // Return false if the input value is null or undefined
-  if (obj === null || obj === undefined) return false
+  if (obj === null || obj === undefined) return false;
 
   // Return false if the classFunction is not a function (constructor)
-  if (typeof classFunction !== 'function') return false
+  if (typeof classFunction !== 'function') return false;
 
   // Get the prototype that we're trying to match
-  const targetPrototype = classFunction.prototype
+  const targetPrototype = classFunction.prototype;
 
   // Convert obj to an object (handles primitives like numbers, strings, etc.)
-  let currentProto = Object(obj)
+  let currentProto = Object(obj);
 
   // Traverse up the prototype chain
   while (currentProto !== null) {
     // If the prototype matches the target, return true
     if (Object.getPrototypeOf(currentProto) === targetPrototype) {
-      return true
+      return true;
     }
 
     // Move one level up the prototype chain
-    currentProto = Object.getPrototypeOf(currentProto)
+    currentProto = Object.getPrototypeOf(currentProto);
   }
 
   // If we reach the end of the chain without a match, return false
-  return false
+  return false;
 }
 
 // * Export the function
-export { checkIfInstanceOf, checkIfInstanceOfUsingPrototype }
+export { checkIfInstanceOf, checkIfInstanceOfUsingPrototype };

src/main.ts

@@ -1,10 +1,10 @@
-import chalk from 'chalk'
+import chalk from 'chalk';
 
 function main() {
-  console.clear()
+  console.clear();
   console.log(
     chalk.green.bold('\n🚀 Welcome to ') + chalk.blueBright.bold('LeetCode JavaScript Practice!\n'),
-  )
+  );
 
   console.log(
     chalk.gray('📚 This is a curated collection of LeetCode problems with:') +
@@ -14,17 +14,17 @@ function main() {
       chalk.cyan('  • Clear explanations') +
       '\n' +
       chalk.cyan('  • Concept-based tagging for deep learning\n'),
-  )
+  );
 
   console.log(
     chalk.yellow('✨ Run ') +
       chalk.magenta('pnpm test') +
       chalk.yellow(' to test all problems or ') +
       chalk.magenta('pnpm test:problem') +
       chalk.yellow(' to run a specific one.\n'),
-  )
+  );
 
-  console.log(chalk.green('Happy coding! 💻\n'))
+  console.log(chalk.green('Happy coding! 💻\n'));
 }
 
-main()
+main();

src/scripts/test-problem.ts

@@ -1,15 +1,15 @@
-import { execSync } from 'child_process'
+import { execSync } from 'child_process';
 
-const problemNumber = process.argv[2]
+const problemNumber = process.argv[2];
 
 if (!problemNumber) {
-  console.error('❌ Please provide a problem number (e.g. 2618)')
-  process.exit(1)
+  console.error('❌ Please provide a problem number (e.g. 2618)');
+  process.exit(1);
 }
 
 try {
-  execSync(`pnpm jest --testPathPatterns=${problemNumber}`, { stdio: 'inherit' })
+  execSync(`pnpm jest --testPathPatterns=${problemNumber}`, { stdio: 'inherit' });
 } catch (err) {
-  console.error('❌ Test run failed.', err)
-  process.exit(1)
+  console.error('❌ Test run failed.', err);
+  process.exit(1);
 }