tests.js

const http = require("http");
const { performance } = require("perf_hooks");

const PORT = 4001;
const CONCURRENT_REQUESTS = 50;
const TEST_ITERATIONS = 10;

const testCases = [
  { input: "5", expectedOutput: "120" },
  { input: "7", expectedOutput: "5040" },
  { input: "3\n4\n1 2 3\n4 5 6\n7 8 9\n2 2 2\n3 3 3\n4 4 4", expectedOutput: "30 36 42\n66 81 96\n102 126 150" }, // Matrix Multiplication
  { input: "5\n5 2 9 1 5", expectedOutput: "1 2 5 5 9" },
];

const codeSamples = {
  python: `
import sys
def factorial(n):
    return 1 if n == 0 else n * factorial(n-1)

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

def matrix_multiply(A, B):
    result = [[sum(A[i][k] * B[k][j] for k in range(len(B))) for j in range(len(B[0]))] for i in range(len(A))]
    return result

lines = sys.stdin.read().split("\\n")
if len(lines) == 1:
    print(factorial(int(lines[0])))
elif len(lines) == 2:
    arr = list(map(int, lines[1].split()))
    print(" ".join(map(str, merge_sort(arr))))
else:
    n, m = map(int, lines[0].split())
    A = [list(map(int, lines[i+1].split())) for i in range(n)]
    B = [list(map(int, lines[i+1+n].split())) for i in range(n)]
    result = matrix_multiply(A, B)
    for row in result:
        print(" ".join(map(str, row)))
  `,

  cpp: `
#include <iostream>
#include <vector>
using namespace std;

long long factorial(int n) {
    return (n == 0) ? 1 : n * factorial(n - 1);
}

void merge(vector<int>& arr, int left, int mid, int right) {
    vector<int> leftArr(arr.begin() + left, arr.begin() + mid + 1);
    vector<int> rightArr(arr.begin() + mid + 1, arr.begin() + right + 1);
    int i = 0, j = 0, k = left;
    while (i < leftArr.size() && j < rightArr.size())
        arr[k++] = (leftArr[i] < rightArr[j]) ? leftArr[i++] : rightArr[j++];
    while (i < leftArr.size()) arr[k++] = leftArr[i++];
    while (j < rightArr.size()) arr[k++] = rightArr[j++];
}

void mergeSort(vector<int>& arr, int left, int right) {
    if (left >= right) return;
    int mid = left + (right - left) / 2;
    mergeSort(arr, left, mid);
    mergeSort(arr, mid + 1, right);
    merge(arr, left, mid, right);
}

int main() {
    int n;
    cin >> n;
    if (n < 10) {
        cout << factorial(n) << endl;
    } else {
        vector<int> arr(n);
        for (int i = 0; i < n; i++) cin >> arr[i];
        mergeSort(arr, 0, n - 1);
        for (int i = 0; i < n; i++) cout << arr[i] << " ";
        cout << endl;
    }
    return 0;
}
  `,

  javascript: `
function factorial(n) {
  return n === 0 ? 1 : n * factorial(n - 1);
}

function mergeSort(arr) {
  if (arr.length <= 1) return arr;
  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));
  return merge(left, right);
}

function merge(left, right) {
  let result = [], i = 0, j = 0;
  while (i < left.length && j < right.length) {
    result.push(left[i] < right[j] ? left[i++] : right[j++]);
  }
  return [...result, ...left.slice(i), ...right.slice(j)];
}

const input = require('fs').readFileSync(0, 'utf8').trim().split("\\n");
const n = parseInt(input[0]);

if (n < 10) {
  console.log(factorial(n));
} else {
  const arr = input[1].split(" ").map(Number);
  console.log(mergeSort(arr).join(" "));
}
  `,

  java: `
import java.util.*;

public class Main {
    static long factorial(int n) {
        return (n == 0) ? 1 : n * factorial(n - 1);
    }

    static void mergeSort(int[] arr, int left, int right) {
        if (left >= right) return;
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }

    static void merge(int[] arr, int left, int mid, int right) {
        int[] leftArr = Arrays.copyOfRange(arr, left, mid + 1);
        int[] rightArr = Arrays.copyOfRange(arr, mid + 1, right + 1);
        int i = 0, j = 0, k = left;
        while (i < leftArr.length && j < rightArr.length)
            arr[k++] = (leftArr[i] < rightArr[j]) ? leftArr[i++] : rightArr[j++];
        while (i < leftArr.length) arr[k++] = leftArr[i++];
        while (j < rightArr.length) arr[k++] = rightArr[j++];
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        if (n < 10) {
            System.out.println(factorial(n));
        } else {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) arr[i] = sc.nextInt();
            mergeSort(arr, 0, n - 1);
            for (int num : arr) System.out.print(num + " ");
            System.out.println();
        }
    }
}
  `,
};

function sendRequest(language, code) {
  return new Promise((resolve) => {
    const startTime = performance.now();
    const requestData = JSON.stringify({ language, code, testCases });

    const options = {
      hostname: "localhost",
      port: PORT,
      path: "/run",
      method: "POST",
      headers: { "Content-Type": "application/json", "Content-Length": requestData.length },
    };

    const req = http.request(options, (res) => {
      let data = "";

      res.on("data", (chunk) => (data += chunk));
      res.on("end", () => {
        const executionTime = performance.now() - startTime;
        resolve({ success: res.statusCode === 200, executionTime, response: data });
      });
    });

    req.on("error", (error) => resolve({ success: false, executionTime: performance.now() - startTime, error: error.message }));

    req.write(requestData);
    req.end();
  });
}

async function tests() {
  console.log("🔥 Starting Parallel Load Test...");

  // Run all languages in parallel
  const languagePromises = Object.keys(codeSamples).map(async (language) => {
    console.log(`\n🔹 Running ${language.toUpperCase()} in parallel...\n`);

    let totalExecutionTime = 0;
    let successCount = 0;
    let failedCount = 0;

    for (let i = 0; i < TEST_ITERATIONS; i++) {
      const promises = Array.from({ length: CONCURRENT_REQUESTS }, () => sendRequest(language, codeSamples[language]));
      const results = await Promise.all(promises);

      results.forEach(({ success, executionTime }) => {
        totalExecutionTime += executionTime;
        success ? successCount++ : failedCount++;
      });

      console.log(`✅ Iteration ${i + 1} completed for ${language}.`);
    }

    console.log(`\n📌 Results for ${language.toUpperCase()}:\n`);
    console.log(`   🔹 Total Requests: ${CONCURRENT_REQUESTS * TEST_ITERATIONS}`);
    console.log(`   ✅ Successful Requests: ${successCount}`);
    console.log(`   ❌ Failed Requests: ${failedCount}`);
    console.log(`   ⏳ Avg Execution Time: ${(totalExecutionTime / (CONCURRENT_REQUESTS * TEST_ITERATIONS)).toFixed(2)} ms\n`);
  });

  await Promise.all(languagePromises);
  console.log("✅ Parallel Load Test Completed.");
}

tests();