DEV Community: G Gokul

React tasks

G Gokul — Mon, 31 Aug 2026 16:14:18 +0000

Task - 1) Toggle Button:

import { useState } from "react";

function Bulb(){
    const [bulb,setBulb] = useState("https://www.w3schools.com/js/pic_bulboff.gif")

    function On(){
        setBulb("https://www.w3schools.com/js/pic_bulbon.gif")
    }
    function Off(){
        setBulb("https://www.w3schools.com/js/pic_bulboff.gif")
    }

    return(
        <div className="div">
            <h1>bulb on/off</h1>
            <img src={bulb} alt="" />
            <button onClick={On}>on</button>
            <button onClick={Off}>off</button>
        </div>
)
}
export default Bulb;

Output:

Task - 2) Input Field Value:

import { useState } from "react";

function Inputfield(){
    const [char,setChar] = useState(" ")

    function Character(){
      const newchar =  document.getElementById("one")
      const element =  newchar.value
      setChar(element)
    }
    return(
        <div className="inputdiv">
            <input onChange={Character} id="one" type="text" />
            <h2>hello, {char}</h2>
        </div>
    )
}
export default Inputfield;

Output:

Task - 3) Show/Hide Text

import { useState } from "react";

function Showhide(){
    const [char,setChar] = useState("")

    function show(){
        setChar("Lorem ipsum dolor sit amet consectetur, adipisicing elit. Veritatis, distinctio!")
    }
    function hide(){
        setChar("")
    }
    return(
        <div className="div">
            <button onClick={show}>show</button>
            <button onClick={hide}>hide</button>
            <p id="new">{char}</p>
        </div>
    )
}
export default Showhide;

Output:

Task - 4) Character Counter

import { useState } from "react";

function Charcounter(){
    const [char,setChar] = useState(" ")

    function Character(){
      const newchar =  document.getElementById("one")
      const element =  newchar.value.length
      setChar(element)
    }
    return(
        <div className="inputdiv">
            <input onChange={Character} id="one" type="text" />
            <h2>{char}</h2>
        </div>
    )
}
export default Charcounter;

Output:

React.js

G Gokul — Thu, 27 Aug 2026 05:07:40 +0000

React.js:

ReactJS is a component-based JavaScript library used for building dynamic and interactive user interfaces.
It enables developers to create reusable UI components and develop fast, scalable single-page applications (SPAs) with efficient rendering and updates.

History of react.js:

React.js was created in 2011 by Jordan Walke, a software engineer at Facebook (now Meta).
Initially developed as an internal prototype to solve complex UI update issues on the Facebook News Feed, it has grown into one of the most widely used front-end JavaScript libraries in the world.

key components of React.js

Components
JSX
Props
State
Hooks
Virtual DOM

Uses of react:

Single-Page Applications (SPAs)
High-Frequency Data Updates
Complex State Management
Component Reusability
Dashboard-Heavy Product
Large-Scale Teams

Why react.js?

React.js is primarily used because it simplifies the creation of dynamic, high-performance user interfaces using reusable code.
React.js was introduced to solve complex code maintenance and slow user interface (UI) rendering performance in large-scale web applications.

difference between library and framework

SPA:

A Single Page Application (SPA) in React is a web application that loads only one single HTML document from the server and then dynamically updates that page as the user interacts with it.

NPM:

npm (Node Package Manager) is the tool used to download, install, and manage the code libraries and tools required to build a React application.
It functions as both a command-line installer and a massive public registry containing millions of reusable JavaScript packages, including React itself.

Creating a project in react.js

First create a folder
Then open terminal
And use this command to create a project

npm create vite@latest

And use this command to run a project

npm run dev

Components in react.js

React components are independent, reusable building blocks that combine business logic, state, and user interface (UI) elements into a single capsule.
They act like JavaScript functions but work in isolation, allowing you to split complex user interfaces into smaller, manageable pieces.
Each component outputs HTML-like structures called JSX.

Primary Types of Components:

1. Functional Components:
These are plain JavaScript functions that accept a single "props" object as an argument and return JSX.
2. Class Components:
These are ES6 classes that extend the base React.Component class and require a render() method to return JSX.

difference between functional components and class components

JSX:

JSX stands for JavaScript XML, and it is a syntax extension for JavaScript used primarily by React to describe what the user interface (UI) should look like.
It allows developers to write HTML-like markup directly inside a JavaScript file, combining visual structure with component logic in one place.

React hooks:

React Hooks are built-in JavaScript functions introduced in React 16.8 that allow you to use state and other React features inside functional components without writing a class component

useState:

useState is a built-in React Hook that allows you to add local state to functional components.
It returns an array containing the current state value and a setter function to update that value.
When the setter function is called, React automatically re-renders the component to reflect the new data on the screen.

Syntax:

import React, { useState } from 'react';
const [state, setState] = useState(initialValue);

state(variable): The current value of the state.
setState(function): The updater function used to change the value and trigger a re-render.
initialValue: The starting value for your state (can be a number, string, boolean, object, array, or null).

Task using useState - counter app

import { useState } from "react"

function Counter(){
    const [count, setCount] = useState(0);
    function increment(){
        setCount(count + 1)
    }
    function decrement(){
        setCount(count - 1)
    }
    function reset(){
        setCount(0)
    }

    return(
        <div className="div">
            <h1>Counter App</h1>
            <h3>Count: {count}</h3>
            <button onClick={increment}>+</button>
            <button onClick={decrement}>-</button>
            <button onClick={reset}>reset</button>
        </div>
    )
}
export default Counter;

Output:

PYTHON TASKS - 8

G Gokul — Wed, 26 Aug 2026 07:39:18 +0000

Task - sum of 2 prime number is given number

Program:

def find_prime(no):
    div = 2
    while div <= no // 2:
        if no % div == 0:
            return False
        div += 1
    else:
        return True

prime1 = 2
target = int(input("Enter a number:"))
while prime1 <= target // 2:
    prime2 = target - prime1
    result = find_prime(prime2)
    if result == True:
        if prime1 + prime2 == target:
            print(prime1, "+", prime2, "=", target)
    prime1 = prime1 + 1

Output:
Enter a number:68
7 + 61 = 68
9 + 59 = 68
15 + 53 = 68
21 + 47 = 68
25 + 43 = 68
27 + 41 = 68
31 + 37 = 68

Task - Sum of 2 consecutive prime number is given number

Program:

def find_prime(no):
    div = 2
    while div <= no // 2:
        if no % div == 0:
            return False
        div += 1
    else:
        return True

prime1 = 2
target = int(input("Enter a number:"))
i = 1
while i <= target // 2:
    prime2 = prime1 + i
    result = find_prime(prime2)
    if result == True:
        if prime1 + prime2 == target:
            print(prime1, "+", prime2, "=", target)
            break
        else:
            prime1 = prime2
            i = 0
    i += 1

Output:
Enter a number:68
31 + 38 = 68

Task - Express 68 and 128 as sum of two consecutive prime Number.

Program:

def find_prime(no):
    div = 2
    while div <= no // 2:
        if no % div == 0:
            return False
        div += 1
    else:
        return True

j = 0
while (j < 2):
    prime1 = 2
    target = int(input("Enter a number:"))
    i = 1
    while i <= target // 2:
        prime2 = prime1 + i
        result = find_prime(prime2)
        if result == True:
            if prime1 + prime2 == target:
                print(prime1, "+", prime2, "=", target)
                break
            else:
                prime1 = prime2
                i = 0
        i += 1
    j = j + 1

Output:
Enter a number:68
31 + 37 = 68
Enter a number:128
61 + 67 = 128

Task - Express 79 and 104 as the sum of any three primes.(TBD)

Program:

def find_prime(no):
    div = 2
    while div <= no // 2:
        if no % div == 0:
            return False
        div += 1
    else:
        return True

j = 0
while(j < 2):
    prime1 = 2
    target = int(input("Enter a number:"))
    while prime1 <= target // 2:
        prime2 = 2
        while prime2 <= target // 2:
            prime3 = target - prime2 - prime1
            if find_prime(prime1) and find_prime(prime2) and find_prime(prime3):
                print(prime1, "+", prime2, "+", prime3, "=", target)
                break 
            prime2 = prime2 + 1
        prime1 = prime1 + 1
    j += 1

Output:
Enter a number:79
3 + 3 + 73 = 79
5 + 3 + 71 = 79
7 + 5 + 67 = 79
11 + 7 + 61 = 79
13 + 5 + 61 = 79
17 + 3 + 59 = 79
19 + 7 + 53 = 79
23 + 3 + 53 = 79
29 + 3 + 47 = 79
31 + 5 + 43 = 79
37 + 5 + 37 = 79
Enter a number:104
2 + 5 + 97 = 104
5 + 2 + 97 = 104
13 + 2 + 89 = 104
19 + 2 + 83 = 104
23 + 2 + 79 = 104
29 + 2 + 73 = 104
31 + 2 + 71 = 104
41 + 2 + 61 = 104
43 + 2 + 59 = 104

Closure and LocalStorage in Javascript

G Gokul — Mon, 24 Aug 2026 15:13:18 +0000

closure:

A closure in JavaScript is a feature where an inner function retains access to the variables of its outer (enclosing) function, even after the outer function has finished executing.

example:

<script>
        function bank(){
        let min_balance = 500;
        const actions = {
            deposit : function (amt){
                min_balance = min_balance + amt;
            },
            withdraw : function (amt){
                min_balance = min_balance - amt
            },
            checkbalance : function(){
                console.log(min_balance)
            }
        }
        return actions;
    }

    const customer1 = bank();
    customer1.deposit(500);
    customer1.checkbalance();
    </script>

output:
1000

Localstorage:

JavaScript localStorage is a feature that lets you store data in your browser using key-value pairs.
The data stays saved even after you close the browser, so it can be used again when you open it later.
This helps keep track of things like user preferences or state across different sessions.

Syntax:

localStorage

Save Data to Local Storage:

localStorage.setItem(key, value);

Read Data from Local Storage:

let lastname = localStorage.getItem(key);

Remove Data from Local Storage:

localStorage.removeItem(key);

Remove All (Clear Local Storage):

 localStorage.clear();

Python tasks - 7

G Gokul — Sun, 23 Aug 2026 10:17:53 +0000

Task - Neon number

A neon number is a positive integer whose sum of the digits of its square, equals the original number. For example, 9 is a neon number because 9^2=81 and 8+1=9.
Program:

def sum_of_digits(no):
    sum = 0
    while no > 0:
        sum = sum + no%10
        no = no//10
    return sum
number = 9 
square = number ** 2
sum = sum_of_digits(square)
if number == sum: 
    print('Neon Number')

Output:
Neon Number

Task - Strong number

Strong Numbers are the numbers whose sum of factorial of digits is equal to the original number. Given a number, the task is to check if it is a Strong Number or not.
Program:

def find_factorial(no):
        factorial = 1
        while no > 0:
            factorial *= no 
            no-=1 
        return factorial 

def digits(no): 
    total = 0
    while no > 0:
        digit = no % 10
        factorial = find_factorial(digit) 
        total += factorial
        no = no//10
    return total 
number = int(input("enter a number:"))                       
result = digits(number) 
if result == number: 
    print("Strong Number")

Output:
enter a number:145
Strong Number

Task - Automorphic Number

An automorphic number is a number whose square ends with the same digits as the number itself, such as 25 (because 25² = 625) or 76 (because 76² = 5776).
Program:

no = int(input("Enter a number: "))
square = no ** 2
digit = 0
no_digit = no
while no_digit> 0:
    digit += 1
    no_digit //= 10
last_digits = square % (10 ** digit)
if no == last_digits:
    print("Automorphic Number")
else:
    print("Not an Automorphic Number")

Output:
Enter a number: 5
Automorphic Number

Task - Duck Number:

A Duck Number is a positive integer that contains at least one 0, but it must not start with 0. For example, 2046 and 2100 are duck numbers, while 0123 is not.
Program:

no = input("Enter no:")
if no[0] == '0':
    print('Not a Duck Number')
else:
    if '0' in no:
        print("Duck Number")
    else:
        print('Not a Duck Number')

Output:
Enter no:1223
Not a Duck Number

Task - Spy Number:

Your are given a number n . The number is said to be a Spy number if the sum of all the digits is equal to the product of all digits.
Eg. 1412
Program:

def sum_of_digits(no):
    sum = 0
    multiply = 1 
    while no > 0:
        sum = sum + no%10
        multiply = multiply * no%10
        no = no//10
    return sum == multiply 

no = 123
result = sum_of_digits(no)
print('Spy Number: ', result)

Output:
Spy Number: True

Python tasks - 6

G Gokul — Fri, 21 Aug 2026 05:12:02 +0000

Task - find count of a digits

Program:

no = int(input ("enter a number:"))
count = 0
while(no>0):
    no%10
    no = no // 10
    count += 1
print(f'count of digit is {count}')

Output:
enter a number:2345
count of digit is 4

Task - find sum of digits

Program:

no = int(input ("enter a number:"))
count = 0
total = 0
while(no>0):
    total = total + no%10
    no = no // 10
    count += 1
print(f'count of digit is {count}')
print(f'sum of digit is {total}')

Output:
enter a number:1234
count of digit is 4
sum of digit is 10

Task - reverse a number

Program:

no = int(input ("enter a number:"))
reverse = 0
while(no>0):
reverse= (reverse*10) + no%10
no = no // 10
print(f'reverse is {reverse}')

Output:
enter a number:4567
reverse is 7654

Task - find given number is palindrome or not

Program:

no = int(input ("enter a number:"))
reverse = 0
copy = no
while(no>0):
    reverse = (reverse*10) + no%10
    no = no // 10
if copy == reverse:
    print("palindrome")
else:
    print("not palindrome")

Output:
enter a number:121
palindrome

Python tasks - 5

G Gokul — Thu, 20 Aug 2026 03:53:06 +0000

Task - A number is a perfect number if the sum of its factors other than the given number gives the same number.

For example, 6 is a perfect number, since
adding the factors of 6 (other than 6), namely 1, 2 and 3 gives the given number 6.
i.e.,1+2+3 = 6 is the given number.

Program:

no =6
total=0
factor = 1
while factor<6:
    if(no%factor==0):
       total=total+factor 
    factor=factor+1
if(no==total):
    print("perfect number")
else:
    print("not perfect")

Flowchart:

Output:
perfect number

1) Divisible by 2:

Take Last Digit.
It should be 0,2,4,6 or 8.

Program:

no = 1212129
last_digit = no%10 
if last_digit in (0,2,4,6,8):
    print('Divisible by 2')
else:
    print("not divisible by 2")

Output:
not divisible by 2

2) Divisible by 3:

The sum of any three consecutive numbers is divisible by 3.
33+34+35 = 102

Program:

no = 15
ones_place = no % 10
tens_place = no // 10 
sum = ones_place + tens_place
if sum%3 ==0:
    print("Divisible by 3")
else:
    print("not divisible by 3")

Output:
Divisible by 3

3) Divisible by 4:

Program:

no = 124
last_two_digits = no % 100
if last_two_digits % 4 == 0:
    print("divisible by 4")
else:
    print("not divisible by 4")

Output:
divisible by 4

4) Divisible by 5:

Program:

no = 125
last_digit = no % 10
if last_digit in (0,5):
    print('Divisible by 5')
else:
    print("not divisible by 5")

Output:
Divisible by 5

5) Divisible by 6:

Program:

no = 126
if no % 2 == 0 and no % 3 == 0:
    print('Divisible by 6')
else:
    print('Not divisible by 6')

Output:
Divisible by 6

6) Divisible by 7:

Program;

no = 126
last_digit = no % 10
remaining = no // 10
result = remaining - (last_digit * 2)
if result % 7 == 0:
    print('Divisible by 7')
else:
    print('Not divisible by 7')

Output:
Divisible by 7

7) Divisible by 8:

Program:

no = 1234
last_3_digits = no % 1000
if last_3_digits % 8 == 0:
    print("Divisible by 8")
else:
    print('not divisible by 8')

Output:
not divisible by 8

8) Divisible by 9:

Program:

no = 126
last_two = no % 100
first_digit = no // 100
sum = first_digit + (last_two // 10) + (last_two % 10)
if sum % 9 == 0:
    print('Divisible by 9')
else:
    print('Not divisible by 9')

Output:
Divisible by 9

9) Divisible by 10:

Program:

no = 120
last_digit = no % 10
if last_digit == 0:
    print('Divisible by 10')
else:
    print('Not divisible by 10'

Output:
Divisible by 10

10) Divisible by 11:

Program:

no = 121
last_two = no % 100
first_digit = no // 100
odd = first_digit + (last_two % 10)
even = last_two // 10
if (odd - even) % 11 == 0:
    print('Divisible by 11')
else:
    print('Not divisible by 11')

Output:
Divisible by 11

11) Divisible by 12:

Program:

no = 120
if no % 3 == 0 and no % 4 == 0:
    print('Divisible by 12')
else:
    print('Not divisible by 12')

Output:
Divisible by 12

Bugs Finding in Software Testing

G Gokul — Wed, 19 Aug 2026 03:17:36 +0000

Task - 1

qe-at-cgi-fi.github.io

bugs in task - 1
toodo spelling bug
placeholder bug
no. of items bug
clear not properly working bug

mandatory steps to do in bugs finding:

Browser Compatibility Testing
Responsive Design: UI - Laptop, Tab, Mobile
Cosmetic Bugs
URL Check
Data Validation: Username, password
Checking all links
Home Page
Orphan Page
Customer: Devices, OS, Browsers
Windows 11, Windows 9, mac, iOS, Android -->
OS Compatibility Testing
Browser Compatibility Testing: Chrome, Firefox, Edge
Safari
Localization Testing:Vernacular Languages
iNTERNATIONALIZATIOn --> i18n Testing
Dark / Light Themes

w3c validator used to check the links:

validator.w3.org

80:20 Principle:
80% problems are really caused by 20% of issues.

task - 2

demo.applitools.com

bugs in task - 2:
Data Validation bug
Broken Links
Cosmetic Bugs
OS Compatibility
Browser Compatibility

Installed Software testing:
example - LibreOffice:
1) Installation Testing:
C:\Program Files --> Default Location, Non-default
2) Uninstallation Testing
3) Upgrade Testing:
- Default Location
- Non-default location
OS Installation Testing
Virtual Machines: Simulators: Emulators

Defect Clustering:

Defect clustering is a core principle in software testing stating that a small number of modules or components contain the majority of all bugs.
Following the 80/20 Pareto rule, about 80% of operational failures stem from roughly 20% of the program's code, meaning bugs do not spread evenly.

functional bug:

A functional bug is an error in a software program that stops a feature from working the way it should.
It happens when an app or website does not do what the rules or user guide say it will do.

Functional testing:

Functional testing is a type of black-box software testing that verifies whether an application's features work exactly as specified by the project requirements.
It focuses purely on "what" the system does rather than how it handles its internal logic, performance, or source code.

Non-functional testing:

Non-functional testing is a type of software testing that evaluates how well a system operates under specific conditions, rather than what functions it performs.
Instead of checking specific features or user actions, it validates critical quality attributes like performance, security, usability, and scalability to ensure a seamless real-world user experience.

difference between functional and non functionality testing

Web Crawlers:

Web crawlers (or spiders) are automated software programs that systematically browse the internet to discover, download, and index content from web pages.
They are primarily used by search engines like Google and Bing to build massive databases so users can find relevant search results quickly.

Difference between priority and severity:

examples:

Bug Reporting - Fields

Severity
Environment: Hardware, Software details:Linux Mint 23, Chrome 105
Steps To Reproduce:

Select Build 2 in the drop down.
Now give any number in number1, number2 fields
Select any arithmetic operation eg. Add
Click 'Calculate' button
Check Results Expected:5 + 5 = 10 Actual: 55 Attachments: Log Reports, Screenshots

Authorization Testing:
Admin
Super user
user
guest
Authentication Testing - Login - Username, Password

difference between authentication and authorization:

sitemap in website:
to know the structure or map of the web.

Task - 3

bugeater.web.app

bugs in task - 3

References:

Examples of high Severity, Priority, and low Severity, Priority defects in your Current Project? | H2K Infosys Blog

Learn real-world examples of high severity and priority defects in software testing, including low-severity issues and how QA teams prioritize bug fixes.

h2kinfosys.com

Authentication vs Authorization: Definitions, Types, and Differences

This article explains the concepts of authentication and authorization and highlights the differences between the two processes.

heimdalsecurity.com

Python tasks-4

G Gokul — Tue, 18 Aug 2026 16:01:40 +0000

Task - Secret VIP Numbers

A security system assigns special numbers to the first few VIP lockers.A number is considered a VIP number if it can be divided exactly by only 1 and itself.The security officer wants the numbers of the first 5 VIP lockers.Write a Python program to display those 5 numbers.
ExpectedResult: 2, 3, 5, 7, 11

Program:

def find_vip_number(no):
    div = 2
    while div <= no//2:
        if no % div == 0:
            return 'not VIP'
        div+=1
    else:
        return 'VIP'
no = 2
count = 0
while count < 5:
    result = find_vip_number(no)
    if result == 'VIP':
        print(no)
        count+=1
    no = no+1

Flowchart:

Output:
2
3
5
7
11

Task - The Special Numbers

A teacher is preparing a Number Exhibition for students. She writes the numbers 1 to 20 on 20 cards. She wants to select only the special cards. A card is special if its number can be divided exactly by only two numbers: 1 and the number itself.

The teacher asks the students:
“Check all the cards from 1 to 20 and display the numbers that are special.”

Program:

def find_vip_number(no):
    div = 2
    while div <= no//2:
        if no % div == 0:
            return 'not VIP'
        div+=1
    else:
        return 'VIP'
no = 1
while no <= 20:
    result = find_vip_number(no) 
    if result == 'VIP':
        print(no)
    no = no+1

Output:
1
2
3
5
7
11
13
17
19

Task - You have Rs. 100 /- One chocolate costs Rs. 5. Every time you buy a chocolate, you get one wrapper. You can exchange 3 wrappers for 1 additional chocolate. What is the maximum number of chocolates you can have with Rs. 100?

Program:

chocolate   = 20
wrapper     = 20

while wrapper >= 3:
    wrapper = wrapper - 3
    chocolate = chocolate + 1
    wrapper = wrapper + 1
else:
    print(chocolate)

Flowchart:

Output:
29

Task - There is one person called Viyan. He is a Software Engineer. He employs a maid for cooking. One day, the maid prepared n number of chapathis and kept in a hot box. Viyan ate those chapathis and the count is as follows:

For Morning breakfast, he completed 1/3 number of chapathis in the hot box.
For Lunch, He had 1/3 of what was there in the hot box.
For Dinner, again he took and ate 1/3 number of chapathis present in the box.
The next day morning, When the maid checked the number of chapathis remaining, it was 8. What was the number of chapathis, She made - in total?

Program:

balance = 8
number = 1
while(number <= 3):
     total = balance // 2
     balance = balance + total
     number = number + 1
else:
    print(balance)

Flowchart:

Output:
27

Software testing topics

G Gokul — Mon, 17 Aug 2026 12:01:21 +0000

Positive test cases:

These are ones in which the system being tested is expected to work correctly.
These tests are designed to show that the system can handle valid input and produce the expected output.

Negative test cases:

These are those in which the system being tested is expected to fail.
These tests help ensure that the system can handle invalid input and produce error messages or other appropriate outputs when necessary.

Destructive test cases:

These are those in which the system being tested is deliberately broken to test its recovery capabilities. These tests help ensure that the system can deal with unexpected failures and still function properly.

Difference between positive test case and negative test case

relationship between test case and test scenario

cross functional testing:

Cross-functional testing holistically evaluates the functionalities of software systems.
It involves product managers, developers, testers, and business analysts from various teams working together to validate the entire system and achieve the desired outcomes.

Unit testing:

A unit test is a software testing method where the smallest testable parts of an application, called units (such as individual functions, methods, or classes), are isolated and verified for correctness.
Typically written and executed by developers during the coding phase, unit testing acts as the first line of defense to catch bugs early before the code is integrated into larger systems.

Integration testing:

Integration Testing is a Software Testing Technique that focuses on verifying the interactions and data exchange between different components or modules of a Software Application.
The goal of Integration Testing is to identify any problems or bugs that arise when different components are combined and interact with each other.

System testing:

System Testing is a software testing level in which the complete and integrated application is tested as a whole to ensure it meets the specified requirements.
It is performed after Integration Testing and before Acceptance Testing to verify the system's overall functionality, performance, and reliability.

Difference between unit, integration and system testing

Types of Integration Testing:

1. Big-Bang Integration Testing

In Big Bang Integration Testing, all modules are integrated at once and tested together as a complete system.
Suitable only for small applications where module count is limited.
Difficult to identify the exact root cause when defects occur.
No incremental testing, so debugging becomes complex and time-consuming.

2. Bottom-Up Integration Testing

In Bottom-Up Integration Testing, lower-level modules are tested first, followed by gradual integration of higher-level modules.
Uses test drivers to simulate higher-level modules that are not yet available.
Focuses on validating internal module logic and data flow first.
Defects in core components are easier to detect and fix early.

3. Top-Down Integration Testing

In Top-down Integration Testing, high-level modules are tested first, and lower-level modules are integrated step by step.
Uses stubs to simulate lower-level modules during early testing.
Helps validate system architecture and major workflows early in development.
Ensures critical business logic is tested before full system integration .

4. Mixed Integration Testing

A combination of both top-down and bottom-up approaches executed in parallel.
Uses both stubs and drivers for simultaneous testing of different layers.
Reduces overall testing time by parallel execution of modules.
Provides balanced coverage of both high-level and low-level system components.

Difference between top down approach and bottom up approach

Test bed:

testbed is a controlled, isolated environment containing the specific hardware, software, network configurations, test data, and tools needed to run and validate tests on a system.
It allows teams to safely evaluate software or technology under realistic conditions without risking live production systems.

Difference between stub and driver

BRS:

BRS stands for Business Requirement Specification (also known as a Business Requirement Document or BRD).
In software testing, it is a high-level document that outlines a client's core business goals, expectations, and product scope using non-technical language.

FRS:

FRS stands for functional requirement specification — a document that outlines all the functions the software or product must perform.

SRS:

SRS stands for Software Requirements Specification.
It is a detailed document that acts as a blueprint or roadmap for a software project.
It describes what the software will do, how it should perform, and the functional and non-functional requirements it must meet to satisfy both the user and the business.

Difference between Brs,Frs and Srs

Difference between error, bug, defect

Cosmetic bugs:

Cosmetic bugs are minor visual flaws in software that affect the look or layout of a user interface but do not stop the program from working.

will developer do testing?

Yes, developers do test code, but they mostly focus on unit tests and component checks rather than full system quality assurance.
Software teams typically use a shared approach where developers handle initial code validation, while dedicated testers handle broader scenarios.

Early testing is good.justify

Early testing is a vital practice that saves money, time, and effort by catching design mistakes and code bugs when they are first made, rather than waiting until the end of a project.

PostgreSQL topics

G Gokul — Sat, 15 Aug 2026 07:43:40 +0000

Difference between Store procedure and function in PostgreSQL

Difference between DDL AND DML AND DQL

Difference between tables and views

Difference between delete and drop and truncate

*Difference between unique and primary key and foreign key and composite key *

Test Case Writing In Software Testing

G Gokul — Fri, 14 Aug 2026 08:35:23 +0000

Software testing:

Software testing is the process of evaluating and verifying that a software application functions correctly, securely, and efficiently according to its business and technical requirements.
Its primary goal is to identify bugs, reduce operational risks, and ensure high product quality before the code is released to production.

Test case:

A test case is a set of conditions, variables, and sequential steps written by QA professionals to verify whether a specific feature of a software application functions correctly and as intended.
Essentially, it acts as a detailed roadmap that provides the precise steps, inputs, and expected outcomes required to validate a software requirement.

why test case is needed?
A test case is needed to provide a clear, step-by-step blueprint that verifies if a software system works correctly, meets requirements, and catches hidden bugs before users find them.

when do you write test case?
Test cases are written during the Test Case Design phase of a project, right after requirements are approved and before the software features are fully tested.

how to write test case in software testing?
To write a test case in software testing, you must convert software requirements into a clear, step-by-step set of instructions that verifies whether a specific feature works as intended.

Components of a Test Case:

Test Case ID: A unique identifier used for tracking and documentation.
Description: A brief summary explaining what functionality is being tested.
Preconditions: The required system state before the test can begin.
Test Data: The specific inputs or variables required for the test steps.
Test Steps: Sequential instructions detailing exactly how to execute the test.
Expected Result: The ideal or required outcome the software should display.
Actual Result:The real behavior of the system observed during execution.
Status: Marked as Pass if the actual result matches the expected result, or Fail if they do not.

Types of Test Cases:(TBD)

Functional: Verifies whether a core feature performs correctly based on functional specifications.
UI (User Interface): Checks for visual accuracy, readability, layout, and responsive design elements.
Performance: Evaluates app speed, stability, and scaling behavior under varied user loads.
Security: Targets vulnerabilities to ensure safe data handling and unauthorized access blocks.
Regression: Confirms that new code modifications do not unintentionally break existing, stable functionality.

Test Scenario:

A high-level description of a feature or a user journey to be tested.
It answers "What to test" from an end-user's perspective.
It is usually written as a single line.

Example test case:

Task

Difference between test case and test scenario: