Add unit tests for 7 components

webapp/src/components/GdbComponents/BreakPoints/__tests__/BreakPoints.test.jsx

@@ -0,0 +1,48 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import BreakPoints from "../BreakPoints.jsx";
+import axios from "axios";
+
+// Mock DataContext
+jest.mock("../../../../context/DataContext", () => ({
+  DataState: () => ({
+    refresh: false,
+    setInfoBreakpointData: jest.fn(),
+    infoBreakpointData: null,
+  }),
+}));
+
+// Mock axios
+jest.mock("axios");
+axios.post = jest.fn().mockResolvedValue({
+  data: { result: "mock breakpoint data" }
+});
+
+test("renders BreakPoints component", () => {
+  const { container } = render(<BreakPoints />);
+  const breakpointsDiv = container.querySelector(".breakpoints");
+  expect(breakpointsDiv).toBeInTheDocument();
+});
+
+test("displays dummy breakpoint data when infoBreakpointData is null", () => {
+  render(<BreakPoints />);
+  const offsetElements = screen.queryAllByText(/0x2fffa36f603112ffff34/i);
+  expect(offsetElements.length).toBeGreaterThan(0);
+});
+
+test("displays dummy breakpoint file path", () => {
+  render(<BreakPoints />);
+  const pathElement = screen.getByText(/t\.js:18/i);
+  expect(pathElement).toBeInTheDocument();
+});
+
+test("BreakPoints has correct div structure", () => {
+  const { container } = render(<BreakPoints />);
+  const breakpointsDiv = container.querySelector("div .breakpoints");
+  expect(breakpointsDiv).toBeTruthy();
+});
+
+test("BreakPoints component renders without crashing", () => {
+  const { container } = render(<BreakPoints />);
+  expect(container).toBeTruthy();
+});

webapp/src/components/GdbComponents/Context/__tests__/Context.test.jsx

@@ -0,0 +1,37 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import Context from "../Context.jsx";
+
+// Mock DataContext (not needed for this component but good practice)
+jest.mock("../../../../context/DataContext", () => ({
+  DataState: () => ({}),
+}));
+
+test("renders Context component", () => {
+  const { container } = render(<Context />);
+  const contextDiv = container.querySelector(".context");
+  expect(contextDiv).toBeInTheDocument();
+});
+
+test("renders Context with cat /proc/maps command", () => {
+  render(<Context />);
+  const catElement = screen.getByText(/cat \/proc/i);
+  expect(catElement).toBeInTheDocument();
+});
+
+test("renders Context with heap memory mapping", () => {
+  render(<Context />);
+  const heapElement = screen.getByText(/heap/i);
+  expect(heapElement).toBeInTheDocument();
+});
+
+test("renders Context with memory address data", () => {
+  render(<Context />);
+  const memoryElements = screen.queryAllByText(/0x5555555592a/i);
+  expect(memoryElements.length).toBeGreaterThan(0);
+});
+
+test("Context component renders without crashing", () => {
+  const { container } = render(<Context />);
+  expect(container).toBeTruthy();
+});

webapp/src/components/GdbComponents/LocalVariable/__tests__/LocalVariable.test.jsx

@@ -0,0 +1,37 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import LocalVariable from "../LocalVariable.jsx";
+
+// Mock DataContext (not needed for this component but good practice)
+jest.mock("../../../../context/DataContext", () => ({
+  DataState: () => ({}),
+}));
+
+test("renders LocalVariable component", () => {
+  const { container } = render(<LocalVariable />);
+  const localVariableDiv = container.querySelector(".localVariable");
+  expect(localVariableDiv).toBeInTheDocument();
+});
+
+test("renders LocalVariable with RAD_T variable", () => {
+  render(<LocalVariable />);
+  const radTElement = screen.getByText(/RAD_T/i);
+  expect(radTElement).toBeInTheDocument();
+});
+
+test("renders LocalVariable with angle variable", () => {
+  render(<LocalVariable />);
+  const angleElement = screen.getByText(/angle 380 double/i);
+  expect(angleElement).toBeInTheDocument();
+});
+
+test("renders LocalVariable with shared_ptr variables", () => {
+  render(<LocalVariable />);
+  const sharedPtrElements = screen.queryAllByText(/globalshred/i);
+  expect(sharedPtrElements.length).toBeGreaterThan(0);
+});
+
+test("LocalVariable component renders without crashing", () => {
+  const { container } = render(<LocalVariable />);
+  expect(container).toBeTruthy();
+});

webapp/src/components/GdbComponents/MemoryMap/__tests__/MemoryMap.test.jsx

@@ -0,0 +1,42 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import MemoryMap from "../MemoryMap.jsx";
+import axios from "axios";
+
+// Mock DataContext
+jest.mock("../../../../context/DataContext", () => ({
+  DataState: () => ({
+    refresh: false,
+    memoryMap: null,
+    setMemoryMap: jest.fn(),
+  }),
+}));
+
+// Mock axios
+jest.mock("axios");
+axios.post = jest.fn().mockResolvedValue({
+  data: { result: "mock memory data" }
+});
+
+test("renders MemoryMap component", () => {
+  const { container } = render(<MemoryMap />);
+  const memoryMapDiv = container.querySelector(".memoryMap");
+  expect(memoryMapDiv).toBeInTheDocument();
+});
+
+test("displays dummy data when memoryMap is null", () => {
+  render(<MemoryMap />);
+  const memoryElements = screen.queryAllByText(/0x7fffffffe270/i);
+  expect(memoryElements.length).toBeGreaterThan(0);
+});
+
+test("MemoryMap has correct div structure", () => {
+  const { container } = render(<MemoryMap />);
+  const memoryDiv = container.querySelector("div .memoryMap");
+  expect(memoryDiv).toBeTruthy();
+});
+
+test("MemoryMap renders without crashing", () => {
+  const { container } = render(<MemoryMap />);
+  expect(container).toBeTruthy();
+});

webapp/src/components/GdbComponents/Threads/__tests__/Threads.test.jsx

@@ -0,0 +1,37 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import Threads from "../Threads.jsx";
+
+// Mock DataContext
+jest.mock("../../../../context/DataContext", () => ({
+  DataState: () => ({}),
+}));
+
+test("renders Threads component", () => {
+  const { container } = render(<Threads />);
+  const threadsDiv = container.querySelector(".threads");
+  expect(threadsDiv).toBeInTheDocument();
+});
+
+test("renders Threads component part1 with func text", () => {
+  render(<Threads />);
+  const funcText = screen.getByText(/func/i);
+  expect(funcText).toBeInTheDocument();
+});
+
+test("renders Threads component part2 with file text", () => {
+  render(<Threads />);
+  const fileText = screen.getByText(/file/i);
+  expect(fileText).toBeInTheDocument();
+});
+
+test("Threads component has threads-component class", () => {
+  const { container } = render(<Threads />);
+  const threadsComponent = container.querySelector(".threads-component");
+  expect(threadsComponent).toBeInTheDocument();
+});
+
+test("Threads renders without crashing", () => {
+  const { container } = render(<Threads />);
+  expect(container).toBeTruthy();
+});

webapp/src/components/MainScreen/__tests__/MainScreen.test.jsx

@@ -0,0 +1,39 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import MainScreen from "../MainScreen.jsx";
+
+// Mock DataContext
+jest.mock("../../../context/DataContext", () => ({
+  DataState: () => ({
+    isDarkMode: "light",
+  }),
+}));
+
+// Mock Monaco Editor
+jest.mock("@monaco-editor/react", () => ({
+  __esModule: true,
+  default: () => <div data-testid="monaco-editor">Editor Mock</div>,
+}));
+
+test("renders MainScreen component", () => {
+  render(<MainScreen />);
+  const mainScreenText = screen.getByText(/MainScreen/i);
+  expect(mainScreenText).toBeInTheDocument();
+});
+
+test("renders with correct CSS class", () => {
+  const { container } = render(<MainScreen />);
+  const mainScreenDiv = container.querySelector(".mainScreen");
+  expect(mainScreenDiv).toBeInTheDocument();
+});
+
+test("shows Editor component", () => {
+  render(<MainScreen />);
+  const editorElement = screen.getByTestId("monaco-editor");
+  expect(editorElement).toBeInTheDocument();
+});
+
+test("MainScreen renders without crashing", () => {
+  const { container } = render(<MainScreen />);
+  expect(container).toBeTruthy();
+});

webapp/src/components/Terminal/__tests__/TerminalComp.test.jsx

@@ -0,0 +1,42 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import TerminalComp from "../TerminalComp.jsx";
+import axios from "axios";
+
+// Mock DataContext
+jest.mock("../../../context/DataContext", () => ({
+  DataState: () => ({
+    terminalOutput: "",
+    commandPress: false,
+  }),
+}));
+
+// Mock axios
+jest.mock("axios");
+axios.post = jest.fn().mockResolvedValue({
+  data: { result: "mock result" }
+});
+
+// Mock react-terminal
+jest.mock("react-terminal", () => ({
+  ReactTerminal: React.forwardRef(() => (
+    <div data-testid="react-terminal">Terminal</div>
+  )),
+}));
+
+test("renders TerminalComp component", () => {
+  render(<TerminalComp />);
+  const terminalElement = screen.getByTestId("react-terminal");
+  expect(terminalElement).toBeInTheDocument();
+});
+
+test("TerminalComp has div with terminal class", () => {
+  const { container } = render(<TerminalComp />);
+  const terminalDiv = container.querySelector(".terminal");
+  expect(terminalDiv).toBeInTheDocument();
+});
+
+test("TerminalComp renders correctly without crashing", () => {
+  render(<TerminalComp />);
+  expect(screen.getByText(/Terminal/i)).toBeInTheDocument();
+});