DEV Community: DAVID ARAVINDHRAJ

Understanding Prime Numbers and How to Find the Nearest Prime in Python

DAVID ARAVINDHRAJ — Sat, 12 Jul 2025 08:45:39 +0000

Prime numbers are a foundational concept in mathematics and programming. If you're preparing for coding interviews or just want to brush up on logic building in Python, learning to work with primes is essential.
In this post, we’ll:

Understand what a prime number is.
Learn the logic to check if a number is prime manually.
Build a Python script to find the nearest prime number from a given input.

🔢 What is a Prime Number?

A prime number is a number greater than 1 that has no positive divisors other than 1 and itself.

✅ Examples:

2, 3, 5, 7, 11, 13, 17...

❌ Not Prime:

1 (by definition)
4 (divisible by 2)
9 (divisible by 3)

💡 How Do You Manually Check If a Number is Prime?

To manually check if a number n is prime:

If n <= 1, it’s not a prime. -If n == 2, it’s a prime (smallest and only even prime).
If n is divisible by 2, it’s not a prime.
Check divisibility from 3 up to √n (square root of n) — if divisible, it's not a prime.

This logic is efficient and avoids unnecessary checks.

🚀 Goal: Find the Nearest Prime to a Given Number

Let’s say a user inputs a number like 10. The nearest primes are 7 (lower) and 11 (upper). Since 11 is closer, the program should return 11.

🧑‍💻 Python Code to Find the Nearest Prime Number


def is_prime(n):
    if n <= 1:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    for i in range(3, int(n ** 0.5) + 1, 2):
        if n % i == 0:
            return False
    return True

def nearest_prime(n):
    if is_prime(n):
        return n

    offset = 1
    while True:
        lower = n - offset
        upper = n + offset
        if lower > 1 and is_prime(lower):
            return lower
        if is_prime(upper):
            return upper
        offset += 1

Example usage

num = int(input("Enter a number: "))
print("Nearest prime:", nearest_prime(num))

🔍 How the Code Works

is_prime(n): Checks if the number is prime using the logic we discussed earlier.
nearest_prime(n):

First, it checks if the number itself is prime.
If not, it expands outward by 1 step each time (offset), checking:
n - offset
n + offset
It returns the first prime it finds, ensuring it's the closest one.

🧪 Example Runs

Enter a number: 10
Nearest prime: 11

Enter a number: 24
Nearest prime: 23

Python Selenium Architecture

DAVID ARAVINDHRAJ — Tue, 17 Sep 2024 17:18:21 +0000

Python Selenium is an open-source tool used to automate web browsers, allowing developers and testers to simulate user interactions with web applications. Its architecture is composed of several key components, all working together to enable browser automation.

Selenium WebDriver: At the core of Selenium's architecture is the WebDriver, an interface that directly communicates with the browser. It acts as a bridge between the code (written in Python) and the browser. Each browser has its own WebDriver implementation (e.g., ChromeDriver for Chrome, GeckoDriver for Firefox). The WebDriver acts as a middleman, interpreting the commands from the Python script and executing them in the browser, while also returning the browser's response to the script.

Client Libraries: Selenium supports multiple programming languages, including Python, Java, C#, and Ruby. When using Selenium with Python, the Python client library is used to write automation scripts. These client libraries provide high-level abstractions for interacting with web elements, performing actions like clicking, sending input, and navigating web pages.

JSON Wire Protocol: Selenium uses the JSON Wire Protocol for communication between the client and the WebDriver. When a Python Selenium script sends a command (such as clicking a button), the command is converted into a JSON format and transmitted to the WebDriver via an HTTP request. The WebDriver interprets the request, executes it in the browser, and sends back the response in JSON format.

Browser-Specific WebDrivers: Each browser has its own WebDriver that knows how to interact with the respective browser. For example, Chrome uses ChromeDriver, Firefox uses GeckoDriver, and Edge has its own WebDriver. These drivers act as intermediaries between Selenium and the browser, ensuring that commands are executed as intended. The WebDriver interacts with the browser via a browser-specific mechanism such as DevTools Protocol (Chrome) or Marionette (Firefox).

Browser: The browser is the actual application being automated. Once the WebDriver receives the command, it controls the browser just as a human user would. It opens web pages, clicks buttons, submits forms, and more. The browser then returns the outcome of these actions, such as the page's HTML or a confirmation message.

Significance of Python Virtual Environment

A Python virtual environment is an isolated environment that allows developers to manage dependencies and libraries on a per-project basis without affecting the global Python installation. It essentially creates a self-contained directory with its own Python interpreter and packages, offering several benefits for managing projects.

Dependency Management: Different projects often require different versions of the same library or package. For example, one project may rely on Django 2.2 while another requires Django 3.0. Installing these packages globally can lead to version conflicts. A virtual environment solves this problem by creating an isolated space where each project can maintain its own dependencies, ensuring compatibility and stability.

Reproducibility: Virtual environments make it easier to reproduce the exact environment on another machine. Using a requirements.txt file, which lists all the dependencies in a virtual environment, one can recreate the same environment in a different system. This is critical for collaboration in teams or deploying code in production. Developers can ensure that the same versions of packages are used, reducing bugs due to version discrepancies.

Global Python Installation Protection: Installing packages globally may affect system-level Python installations, potentially breaking system scripts or other applications. Virtual environments prevent this by keeping project-specific packages separate from the global Python environment. This ensures that experimenting with new libraries or packages does not interfere with the rest of the system.

Project-Specific Environments: Virtual environments allow projects to be independent of each other. Each project can maintain its own set of packages, even if those packages are of different versions. This prevents package clashes across projects, which is especially important for large teams or organizations working on multiple projects simultaneously.

For example, a developer working on two separate Flask and Django projects can create two virtual environments. One will hold Flask and its dependencies, while the other will maintain the specific versions of Django required. Thus, the Flask project remains unaffected by Django’s libraries and vice versa. This kind of project isolation is crucial for efficient software development and testing.

Pk finds it difficult to judge the minimum element in the list of elements given to him.

DAVID ARAVINDHRAJ — Mon, 26 Aug 2024 08:14:33 +0000

Pk finds it difficult to judge the minimum element in the list of elements given to him. Your task is to develop the algorithm in order to find the minimum element.

Sample Input :
5
3 4 9 1 6

Sample Output :
1

#method to find minimum element from a list
def pk_find_min(arr):
    n = len(arr)
    #initialize first list element to 'min'
    min = arr[0]
    for i in range(n-1,0,-1):
        #compare list element with 'min' and overwrite 'min' with minimum element
        if min > arr[i]:
            min = arr[i]
    return(min)


if __name__ == "__main__":
    n = int(input())
    ip_list = list(input().split())
    print(pk_find_min(ip_list))

What is selenium? Why do we use selenium for Automation?

DAVID ARAVINDHRAJ — Mon, 26 Aug 2024 08:10:23 +0000

Selenium is an open-source automation tool designed for testing web applications across different browsers and platforms. Originally developed by Jason Huggins in 2004.
Selenium allows testers and developers to automate web interactions, perform browser testing, and validate web applications effectively. It provides the ability to simulate user actions, such as clicking, typing, navigating in browsers like Chrome, Firefox, Safari, and Edge.

What is selenium? Why do we use selenium for Automation?

DAVID ARAVINDHRAJ — Sat, 24 Aug 2024 07:21:55 +0000

What is selenium?

Selenium is an open-source automation tool designed for testing web applications across different browsers and platforms. Originally developed by Jason Huggins in 2004.

Selenium allows testers and developers to automate web interactions, perform browser testing, and validate web applications effectively. It provides the ability to simulate user actions, such as clicking, typing, navigating in browsers like Chrome, Firefox, Safari, and Edge.

Compatibility of selenium

Selenium is widely used because it supports multiple programming languages like Java, Python, C#, JavaScript, Ruby, and Kotlin, which gives the flexibility to write their automation scripts in a language they are comfortable with.

This cross-language support is highly advantageous, especially in teams where different programming languages are utilized.

Additionally, Selenium supports multiple operating systems, such as Windows, macOS, and Linux, making it versatile across different environments.

Selenium for Automation

Selenium is popular for automation for its ability to automate browsers. The main objective of Selenium is to automate repetitive and time-consuming tasks that testers would otherwise perform manually.

By scripting these tasks, Selenium enables fast, accurate, and consistent testing, which is critical in ensuring the quality of a web application.

Whether it's performing regression testing, functional testing, or load testing, Selenium is capable of executing scripts that interact with the user interface of the web application just like a real user would.

Selenium Tool Suite

The Selenium suite is composed of several tools, each with distinct purposes.

Selenium WebDriver is the most widely used tool. It allows for direct communication with web browsers and interacts with them in the same way a human user would. This makes it ideal for mimicking real user behavior in tests.

Selenium IDE is another tool in the suite and is primarily used for record-and-playback functionalities. It allows testers to record their interactions with a web application and then replay them to verify that the application behaves as expected.

Selenium Grid allows users to distribute tests across multiple machines, browsers, and operating systems in parallel, thereby reducing the time required to run large test suites.

Selenium for Software Testing

Automation with Selenium becomes an essential part of the development lifecycle, as it integrates seamlessly with popular CI/CD tools like Jenkins, Bamboo, and Travis CI.

By automating tests and integrating them into the build process, teams can ensure that new code changes don’t break existing functionality.

This kind of regression testing is crucial for maintaining the stability of the application while allowing rapid deployment of new features and updates.

Selenium community support

Significant benefit of Selenium is its community support.

Being open-source, it is continually improved by a large community of developers and contributors who provide updates, fix bugs, and plugins to enhance its functionality.

This makes it a go-to tool for web application testing in both small and large-scale projects.

Conclusion

In conclusion, Selenium is a powerful tool for automating browser-based tasks. It supports various programming languages, OS and browsers makes it a preferred choice for web automation. Selenium plays a critical role in modern software development and testing environments to improve efficiency and accuracy in the validation of web applications.

PAT Task 4

DAVID ARAVINDHRAJ — Wed, 27 Mar 2024 14:07:18 +0000

What is manual testing?

Manual testing is the software testing procedure which is being done by manually to ensure whether the application is working, as mentioned in the requirement document or not. In manual testing no automation tools used.
Test cases will be written and executed manually. And it will cover almost 100% of the software application. Also, the reports are prepared manually.

Manual testing is the most fundamental technique to identify the defects in the software application. And it is very much needed since 100% of the software cannot be tested using automation tools.

Manual testing further classified as below

White box testing
Black box testing
Grey box testing

White box testing

White box testing will be done be the developers. In this, developers will test each and every line of the codes to ensure the internal code structure is working perfectly with given and inputs and expected output as per the requirements.

In white box testing, code is visible to tester(developer), so it is also called Clear box testing, Open box testing, Transparent box testing, Code-based testing, and Glass box testing.

Once the developers completed white box testing then the software application will be sent to black box testing which will be done by testing team.

Black box testing

Black box testing involves testing a software application with no prior knowledge of its internal workings. By giving an input, observes the output generated by the software application under test. This makes it possible to identify how the system responds to expected and unexpected user actions, its response time, usability issues and reliability issues.

In Black box testing code is not visible to tester, hence the tester act like end-users who don’t know how a software is coded, and expect to receive an appropriate response to their requests.

Black box testing classified to Functional testing and Non-functional testing.

Functional testing

Functional testing is a type of testing that validates the software application against the functional requirements/specifications. The purpose of Functional tests is to test each function of the software application, by providing appropriate input, verifying the output against the Functional requirements.

Some types of Functional testing are Unit testing, Integration testing, system testing etc.,

Non-functional testing

Non-Functional Testing is defined as a type of testing to check non-functional aspects (performance, usability, reliability, etc) of a software application. It is designed to test the readiness of a system as per non-functional parameters which are never addressed by functional testing. An excellent example of a non-functional test would be to check how many people can simultaneously login into a software.

Some types of Non-functional testing are Performance testing, Usability testing, Compatibility testing etc.,

Advantages of Manual testing

Manual testing can perform from the beginning stage of software development lifecycle even before development completed.
Manual testing has no limitation in test case scripts. It can perform with unpredictable cases also.
Manual testers can act as end-users and perform testing with user perspective where automation cannot perform in such a way.
Manual testing can identify visual defects like style, color, alignment etc.,
Manual testing is maintaining details documents with better test cases, test scenarios, data and result. It will increase quality and re-usability.

Disadvantages of Manual testing

Manual testing and result report take more time and effort especially for frequently repeated test cases. Automated tests provide faster test execution.
Manual testing has limited test coverage compared to automation which can run much larger test suites.
Manual testing is heavily dependent on individual tester skill. Automation provides consistent testing with pre-defined test handling.
Adding new test scenarios and test data requires continuously updating manual test cases. Automated tests are easier to scale across parameters.
Consolidated tracking, analysis and reporting of manual test execution status, progress, results etc. across teams can become highly complex.

For example,
Let’s take any e-commerce website like Flipkart, Amazon and discuss the benefits and drawbacks of manual testing.

Benefits of manual testing

If user type “micro” in search box then microwave oven, microphone, microscope can show in the results. However, if “Microscope” shown for the search of “microphone” then it can only identify in manual testing
Visual things like picture of the product, alignment, color etc., are good to go with manual testing for better results.
As act as end-user, we can test the software with all possibilities of user activities like sellers UI, customer UI or inappropriate use of user.

Drawbacks of manual testing

If it is required to test the software with more number of login credentials like more than 1000 then it will take a long time in manual testing and automation testing can complete the task with minimum time consumption.
Internal functional testing like offers for different types of cards and payment methods can be done in automation testing only.

What is the difference between functional testing and non-functional testing?

DAVID ARAVINDHRAJ — Thu, 21 Mar 2024 22:58:15 +0000

In software testing, two critical categories of tests exist.

Functional testing
Non-functional testing

Functional Testing
Functional testing primarily focuses on verifying that the software operates according to the specified functional requirements. This type of testing checks the user interface, APIs, databases, security, and other essential functionalities by comparing the actual output to the expected results.

For example, consider an e-commerce website.
Functional testing in this case would verify that users can successfully search for products, add items to their cart, complete the checkout process, and receive order confirmation.
Test cases would be created for all these features, and testers would execute them to ensure that the system behaves as per the functional requirements.

Non-Functional Testing
Non-functional testing is concerned with the performance, usability, reliability, and overall quality attributes of the software. It tests the "how" rather than the "what" of the system.
Non-functional testing evaluates characteristics that may not be related to specific functionalities but are crucial for the software to perform well under various conditions.

For example, consider an e-commerce website.
Non-functional testing would assess how quickly the website loads under normal traffic conditions, how it handles a surge in visitors during sales events, and how secure the payment processed from cyber threats.
Performance testing, load testing, stress testing, security testing, and scalability testing are all types of non-functional tests that ensure the system performs adequately and remains stable under varying loads and conditions.

Functional testing ensures that the software's features work as intended, whereas Non-functional testing ensures that the system's performance and quality meet the necessary standards under varying conditions.

Both are crucial in delivering reliable, user-friendly, and high-performing software. By integrating both testing methods into the development lifecycle, organizations can ensure their software not only functions properly but also performs well in the real world.

PAT Task 2

DAVID ARAVINDHRAJ — Thu, 21 Mar 2024 22:21:01 +0000

Please find below testing techniques

1. Boundary value analysis
Boundary value analysis (BVA) is a Black-box testing procedure in software testing.

BVA is a testing method to check the application functionality with boundary values. Minimum and maximum values are the boundary values.

Any inputs in the application have a minimum and maximum limit of value for both valid and invalid entries.

For example:
In a company, age limit for the employee should be from 21 to 55.

Here minimum valid boundary value is 21 and maximum is 55.
Since invalid boundary values are the values which below 21 and above 55.

2. Decision table testing
Decision table testing is a method to test the response of the software with various inputs which includes valid and invalid values.

Decision table will contain all the possible scenarios of valid and invalid inputs to the application. Hence this method is very useful to identify in which case the application is not functioning as expected.

For example:
Lets take a form which has 3 details like name, ph #, photo. Below is the description table.

3. Use Case testing
Use case testing is a method to check a end-to-end functionality of an application unlike testing each components individually. It is one of black box testing procedure basically done by developers.

It used to understand the behavior of an application if it works as per the requirements from client.

Benefits

Uses to identify the functional requirement of any feature
Simple way of view and test cases
Testing from user’s point of view

Drawbacks

Since it observed as from user’s end, there is possibilities of missing any required functionalities.

4. LCSAJ Testing
Linear code sequence and Jump is a white box testing method which is to identify coverage of the code.

The objective of LCSAJ testing is to identify and verify that the code executes correctly in scenarios where it follows linear paths and makes jumps to other sections of the code.

It uses to identify the code coverage from start to end or from any branch to end of the code. It also uses to identify how much codes have executed with existing test cases hence new test cases can be build based on its result.

For example,
consider a program that includes an "if-else" statement:

LCSAJ testing would involve analyzing the sequence of operations from the start of the "if" condition, through the execution of statements inside the block, and then jumping to either the "else" block or the next section of code.

This technique ensures that the code flows correctly and handles jumps, branches, or loops without introducing errors such as unexpected behaviors or logical failures.

What is the relevance of software testing?

DAVID ARAVINDHRAJ — Fri, 15 Mar 2024 06:31:41 +0000

Testing is useful to identify errors in development and compare actual outcome with expected outcome to make sure product quality before deliver to client.

What we need to know about software testing?

DAVID ARAVINDHRAJ — Fri, 15 Mar 2024 06:21:53 +0000

We need to know about different stages of testing and its requirements.

What is software testing? What we need to know about software testing? What is the relevance of software testing?

DAVID ARAVINDHRAJ — Fri, 15 Mar 2024 06:21:09 +0000

What is software testing

Software testing is a critical part of the software development lifecycle that ensures the quality, functionality, performance, and security of software applications.
It involves evaluating and verifying that a software program performs as expected and meets the required standards and specifications.
The ultimate goal of software testing is to identify any defects or issues within the software before it is released to end users, thereby enhancing its reliability, efficiency, and overall user experience.

Software testing is not a one-time activity but rather an ongoing process that begins early in development and continues throughout the entire lifecycle of the software.
This process is often divided into various phases, such as unit testing, integration testing, system testing, and user acceptance testing (UAT).
Each phase serves a specific purpose and focuses on different aspects of the software.

Unit testing is typically the first phase and involves testing individual components or pieces of code to ensure they work as expected in isolation.
Integration testing follows and verifies that different modules or units of the software work together as intended.
System testing then evaluates the entire system as a whole, examining its behaviour under various conditions and scenarios to ensure that it functions as required.
User acceptance testing focuses on the end-user experience, verifying that the software meets the needs and expectations of its target audience.

Manual testing involves human testers performing tests by interacting with the software directly, often following predefined test cases and scripts.
Automated testing, uses specialized tools and scripts to execute tests automatically. This approach is particularly useful for repetitive tasks, regression testing, and large-scale projects where speed and efficiency are paramount.

The relevance of software testing

Inadequate testing can result in software defects, vulnerabilities, and system failures, which can lead to user dissatisfaction, financial losses, and damage to an organization's reputation.
Moreover, thorough testing allows developers to identify and resolve issues early, reducing the cost of fixing bugs in later stages of development and minimizing risks associated with software deployment.

In conclusion, software testing is a fundamental practice in software development that guarantees the delivery of high-quality, reliable, and secure software products.