Introduction

Every Selenium automation script eventually interacts with a WebElement.

Whether you're automating a login page, completing a registration form, validating an error message, checking whether a button is enabled, or verifying if a checkbox is selected, almost everything revolves around the methods available in the WebElement interface.

Because of this, interviewers frequently ask questions related to WebElement methods. They also expect automation engineers to know when and why to use each method in real-world projects.

This practice guide helps you master these methods through structured exercises that progress from beginner-level tasks to advanced interview scenarios.

By completing every exercise in this guide, you'll gain practical experience with:

• Entering and clearing text
• Clicking different UI elements
• Reading visible text
• Reading HTML attributes
• Validating UI states
• Performing safe element interactions
• Building reusable automation utilities

Methods Covered in This Practice Guide

This article focuses on the eight most commonly used Selenium WebElement methods.

These methods form the foundation of almost every Selenium automation framework.

Level 1 – Beginner Practice Exercises (0–1 Year Experience)

This section focuses on understanding how each WebElement method behaves.

The goal is not just to make the script work, but to understand:

• when to use the method,
• what value it returns,
• common mistakes,
• and how it behaves in different situations.

sendKeys() Practice Exercises

The sendKeys() method is used to type text into input fields such as usernames, passwords, search boxes, email fields, phone numbers, and comments.

Beginner Exercises

1. Enter a username into a login page.
2. Enter a password.
3. Clear the username and enter another username.
4. Enter text without using Thread.sleep().
5. Verify the textbox is enabled before entering text.
6. Enter text into a search box.
7. Submit the search using the Enter key.
8. Enter text into multiple fields on the same page.
9. Replace an existing value with a new value.
10. Enter special characters into a textbox.
11. Enter numbers only.
12. Enter alphanumeric values.
13. Enter a long paragraph into a textarea.
14. Enter an empty string.
15. Enter spaces only.
16. Enter Unicode characters.
17. Enter text into an autofilled field.
18. Enter text into a required field.
19. Attempt to enter text into a disabled field and observe the behavior.
20. Compare manual typing with Selenium's sendKeys() execution.

Learning Objectives

After completing these exercises, you should understand:

• How Selenium types into input elements
• Why enabled checks are important
• Why clearing fields before entering data improves reliability
• Common exceptions when interacting with disabled fields

click() Practice Exercises

The click() method performs mouse clicks on buttons, links, radio buttons, checkboxes, images, and many other interactive elements.

Beginner Exercises

1. Click the Login button.
2. Click a Register link.
3. Click a Forgot Password link.
4. Click a Submit button.
5. Click a radio button.
6. Click a checkbox.
7. Click multiple checkboxes.
8. Click a Save button.
9. Click a Cancel button.
10. Click an image acting as a button.
11. Click a menu item.
12. Click an icon.
13. Click a navigation link.
14. Click an element after verifying it is displayed.
15. Click an element after verifying it is enabled.
16. Click a button that opens another page.
17. Click an element inside a form.
18. Click a button inside an iframe.
19. Attempt to click a hidden element and observe the exception.
20. Compare clicking manually versus Selenium automation.

Learning Objectives

You should now understand:

• Which elements support click()
• Why visibility checks improve stability
• Why clicking hidden elements causes failures
• The importance of waiting for elements before interaction

clear() Practice Exercises

The clear() method removes existing text from editable fields.

It is commonly used before entering new data during validation and data-driven testing.

Beginner Exercises

1. Clear the username field.
2. Enter a new username after clearing.
3. Clear the password field.
4. Clear a search box.
5. Clear a textarea.
6. Clear an auto-filled field.
7. Clear only when the field already contains data.
8. Clear a numeric field.
9. Clear a field before retrying a failed login.
10. Clear a field after validation errors.
11. Clear a form before entering another dataset.
12. Clear multiple fields one by one.
13. Clear a field after successful submission.
14. Observe behavior when calling clear() on an empty field.
15. Compare manual deletion versus Selenium's clear().

Learning Objectives

These exercises help you understand:

• When clear() should be used
• Why automation should not append values accidentally
• How clear() supports data-driven testing

getText() Practice Exercises

The getText() method retrieves the visible text displayed on the webpage.

It is widely used for validations during automation.

Beginner Exercises

1. Capture the page heading.
2. Read a login error message.
3. Validate a success message.
4. Capture button text.
5. Capture link text.
6. Read warning messages.
7. Read validation messages.
8. Read text after page refresh.
9. Capture dynamically changing text.
10. Compare actual text with expected text.
11. Validate confirmation messages.
12. Read labels beside input fields.
13. Read table cell values.
14. Read breadcrumb navigation.
15. Read footer text.

Learning Objectives

By completing these exercises, you'll understand:

• Which text Selenium can retrieve
• The difference between visible text and hidden HTML
• Why getText() is widely used in assertions

getAttribute() Practice Exercises

The getAttribute() method retrieves HTML attribute values instead of visible text.

This is especially useful for input fields because entered values are stored in the value attribute.

Beginner Exercises

1. Retrieve the value attribute from a textbox.
2. Capture placeholder text.
3. Capture the class attribute.
4. Retrieve the ID attribute.
5. Retrieve the name attribute.
6. Retrieve the href attribute from a link.
7. Retrieve the title attribute.
8. Validate readonly fields.
9. Retrieve the value after using sendKeys().
10. Read custom data attributes.
11. Retrieve hidden attributes.
12. Compare getText() versus getAttribute().
13. Validate CSS classes.
14. Validate dynamically changing attributes.
15. Read tooltip information stored in the title attribute.

Learning Objectives

You should now understand:

• Why input values require getAttribute("value")
• When getText() is insufficient
• How HTML attributes help validate UI behavior

isDisplayed() Practice Exercises

The isDisplayed() method checks whether an element is currently visible to the user.

Visibility validation is one of the most common automation assertions.

Beginner Exercises

1. Verify the company logo is displayed.
2. Verify a login form is visible.
3. Check whether an error message appears.
4. Verify an element hidden by default.
5. Verify a popup after clicking a button.
6. Check a loading indicator.
7. Verify visibility after page refresh.
8. Verify visibility after AJAX loading.
9. Check if a modal dialog is displayed.
10. Verify a success notification appears.
11. Verify an element disappears after an action.
12. Observe the behavior when the element does not exist.
13. Compare hidden versus invisible elements.
14. Validate conditional UI visibility.
15. Check visibility before clicking an element.

isEnabled() Practice Exercises

The isEnabled() method determines whether a user can interact with an element.

It is especially useful before clicking buttons or entering text.

Beginner Exercises

1. Verify the Login button is enabled.
2. Check whether the Submit button is disabled initially.
3. Verify the button becomes enabled after entering valid input.
4. Validate enablement after selecting a checkbox.
5. Check a disabled input field.
6. Verify enablement after completing mandatory fields.
7. Validate role-based enablement.
8. Check enablement after page refresh.
9. Verify enabled status before calling sendKeys().
10. Compare enabled behavior across different browsers.
11. Validate dynamic enablement.
12. Verify buttons inside modal dialogs.
13. Observe disabled button behavior.
14. Validate enablement after AJAX completion.
15. Build the habit of checking enablement before interaction.

isSelected() Practice Exercises

The isSelected() method verifies whether checkboxes or radio buttons are selected.

Beginner Exercises

1. Verify a checkbox is not selected by default.
2. Select the checkbox.
3. Verify the checkbox is selected.
4. Verify a radio button is selected.
5. Validate the default radio button.
6. Select multiple checkboxes.
7. Verify all selected checkboxes.
8. Unselect applicable checkboxes.
9. Verify selection after page refresh.
10. Validate checkbox persistence.
11. Verify selection before form submission.
12. Validate selected options in a preferences form.
13. Check selection after navigating between pages.
14. Compare selected versus enabled states.
15. Observe behavior when checking already selected elements.

Practice Tips

As you complete these exercises:

• Focus on understanding the behavior of each method instead of simply making the script pass.
• Avoid using unnecessary hard waits.
• Always validate element state before performing actions.
• Practice on multiple websites to observe different UI behaviors.
• Repeat each exercise until you can write the code without referring to documentation.

Mastering these eight methods will make learning advanced Selenium topics significantly easier.

Real-Time Practice Exercises (1–3 Years Experience)

Once you've mastered the basic WebElement methods, the next step is learning how they are used together in real-world automation projects.

Unlike beginner exercises, these scenarios simulate actual business workflows where multiple WebElement methods work together to validate complete user interactions.

Instead of simply clicking a button or entering text, you'll validate complete user journeys such as login, registration, search, checkout, profile updates, and dynamic UI behavior.

These exercises help bridge the gap between learning Selenium and working on enterprise automation frameworks.

Real-Time Exercise 1 – Validate Login Error Messages

Objective

Validate that the application displays the correct error message when invalid credentials are entered.

Practice Tasks

• Enter an invalid username.
• Enter an invalid password.
• Click the Login button.
• Verify the error message is displayed.
• Capture the error message using getText().
• Compare the actual and expected message.
• Validate that the login page remains displayed.
• Verify the Login button is still enabled.

Skills Covered

• sendKeys()
• click()
• getText()
• isDisplayed()
• isEnabled()

Real-Time Exercise 2 – Validate Button Enablement

Many modern applications keep buttons disabled until all mandatory fields are completed.

Practice Tasks

• Open a registration page.
• Observe that the Submit button is disabled.
• Enter only one mandatory field.
• Verify the button remains disabled.
• Complete every mandatory field.
• Verify the Submit button becomes enabled.
• Click the button.
• Validate successful submission.

Skills Covered

• sendKeys()
• isEnabled()
• click()

Real-Time Exercise 3 – Checkbox Controls Button State

A common business rule is accepting Terms & Conditions before continuing.

Practice Tasks

• Verify the Continue button is disabled.
• Check the Terms checkbox.
• Verify the Continue button becomes enabled.
• Uncheck the checkbox.
• Verify the button becomes disabled again.
• Repeat the validation several times.

Skills Covered

• click()
• isSelected()
• isEnabled()

Real-Time Exercise 4 – Validate Placeholder Text

Placeholder validation is frequently performed during UI testing.

Practice Tasks

• Locate the Username textbox.
• Retrieve the placeholder attribute.
• Validate the placeholder text.
• Repeat for Email.
• Repeat for Password.
• Compare expected versus actual values.

Skills Covered

• getAttribute()

Real-Time Exercise 5 – Validate Tooltip Text

Many applications use tooltips instead of labels.

Practice Tasks

• Hover over an information icon.
• Retrieve the title attribute.
• Validate the tooltip text.
• Verify it matches business requirements.

Skills Covered

• getAttribute()

Real-Time Exercise 6 – Dynamic Success Messages

Many applications display temporary success notifications.

Practice Tasks

• Submit a form.
• Wait until the notification appears.
• Verify it is displayed.
• Capture the message.
• Compare expected text.
• Verify the notification disappears automatically.

Skills Covered

• click()
• getText()
• isDisplayed()

Real-Time Exercise 7 – Validate Entered Values

Input fields store typed data inside the HTML value attribute.

Practice Tasks

• Enter data into multiple textboxes.
• Retrieve each value using getAttribute("value").
• Verify every entered value.
• Compare with test data.

Skills Covered

• sendKeys()
• getAttribute()

Real-Time Exercise 8 – Validate AJAX Loading

Modern applications frequently load data asynchronously.

Practice Tasks

• Click a button that triggers AJAX.
• Wait for loading completion.
• Verify the new element becomes visible.
• Capture the displayed text.
• Validate successful loading.

Skills Covered

• click()
• isDisplayed()
• getText()

Real-Time Exercise 9 – Edit Mode vs View Mode

Enterprise applications often have editable and read-only screens.

Practice Tasks

• Open a profile page.
• Verify fields are disabled.
• Click Edit.
• Verify fields become enabled.
• Modify the data.
• Save changes.
• Verify fields become read-only again.

Skills Covered

• isEnabled()
• sendKeys()
• click()

Real-Time Exercise 10 – Verify Checkbox Persistence

Applications frequently remember user selections.

Practice Tasks

• Select multiple preferences.
• Save the form.
• Refresh the page.
• Verify selections remain.
• Repeat using different combinations.

Skills Covered

• click()
• isSelected()

Level 3 – Advanced Practice Exercises (3–5 Years Experience)

Senior automation engineers rarely write simple Selenium scripts.

Instead, they build reusable frameworks that automatically validate element states, recover from failures, and execute reliably in CI/CD pipelines.

The following exercises simulate situations experienced automation engineers face every day.

Exercise 1 – Validate Element State Before Every Action

Never interact with an element immediately.

Always verify:

• Element exists
• Element is visible
• Element is enabled
• Correct page has loaded

Goal

Develop the habit of safe automation instead of optimistic automation.

Exercise 2 – Create Reusable Action Methods

Instead of writing:

driver.findElement(locator).click();

Create reusable methods like:

• click()
• enterText()
• getText()
• clearText()
• verifyVisible()

Goal

Reduce duplicate code.

Improve framework maintainability.

Exercise 3 – Handle Stale Elements

Practice recovering from:

• Page refresh
• AJAX refresh
• Table refresh
• Dynamic lists

Tasks

• Trigger a stale element.
• Re-locate the element.
• Retry the action.
• Validate success.

Exercise 4 – Ignore Case and Extra Spaces

Applications sometimes display inconsistent text.

Practice validating text by ignoring:

• Leading spaces
• Trailing spaces
• Multiple spaces
• Uppercase vs lowercase differences

Exercise 5 – Cross-Browser Validation

Execute the same validation in:

• Chrome
• Firefox
• Edge

Compare:

• Visibility
• Enablement
• Text retrieval
• Attribute values

Exercise 6 – Validate UI Using Attributes

Instead of relying only on visible text:

Validate:

• class
• style
• disabled
• readonly
• aria-label
• data-testid

This technique is heavily used in enterprise projects.

Exercise 7 – Handle Intermittent Visibility Issues

Simulate delayed loading.

Practice:

• Waiting properly
• Rechecking visibility
• Avoiding Thread.sleep()

Exercise 8 – Parallel Execution Validation

Execute checkbox validations simultaneously.

Verify:

• Thread safety
• Driver independence
• No shared WebElement issues

Exercise 9 – Debug Flaky Click Failures

Create scenarios where clicks fail because of:

• Loading overlays
• Disabled buttons
• Animation
• Delayed rendering

Practice identifying the root cause instead of forcing clicks.

Exercise 10 – Implement a Safe Click Strategy

Instead of immediately clicking:

1. Verify visibility.
2. Verify enablement.
3. Scroll if necessary.
4. Wait until clickable.
5. Perform click.
6. Validate the expected result.

This approach significantly reduces flaky automation.

Interview Practical Tasks (Very Common)

These are the practical questions interviewers frequently ask candidates with 2–5 years of Selenium experience.

Practice explaining your approach while demonstrating the automation.

Task 1 – Validate Login Error Message

Scenario:

Invalid credentials are entered.

Expected Outcome:

• Error message appears.
• Correct message is displayed.
• Login button remains available.

Task 2 – Verify Button Enablement

Scenario:

Button should only become clickable after mandatory fields are completed.

Validate:

• Disabled state
• Enabled state
• Successful click

Task 3 – Verify Checkbox Selection

Scenario:

Newsletter subscription.

Tasks:

• Verify default state.
• Select checkbox.
• Verify selection.
• Submit form.
• Validate persistence.

Task 4 – Enter Text Only When Enabled

Scenario:

Application enables fields after loading.

Tasks:

• Wait.
• Verify enabled.
• Enter text.
• Validate entry.

Task 5 – Click Only When Visible

Scenario:

Dynamic button appears after loading.

Tasks:

• Verify visibility.
• Click.
• Validate navigation.

Task 6 – Validate UI Using HTML Attributes

Instead of visible text, validate:

• placeholder
• value
• readonly
• disabled
• class
• href

Task 7 – Validate Error Message Lifecycle

Scenario:

• Error appears.
• User corrects input.
• Error disappears.

Validate both conditions.

Task 8 – Verify Form Reset

Scenario:

User clicks Reset.

Validate:

• Fields cleared.
• Checkboxes reset.
• Radio buttons restored.
• Default values returned.

Task 9 – Complete Form Submission

Automate:

• Enter data.
• Submit.
• Validate success.
• Validate entered values.
• Validate confirmation message.

Task 10 – No Hard Wait Automation

Complete an entire workflow without using:

• Thread.sleep()

Instead use:

• Explicit waits
• ExpectedConditions
• Element state validation

This is one of the most common interview expectations for experienced Selenium engineers.

Best Demo Websites for Practice

The following websites are excellent for practicing WebElement methods because they contain realistic forms, buttons, validation messages, dynamic elements, and state changes.

Practice Recommendation

Rather than completing all exercises on a single website, repeat the same WebElement methods across multiple applications.

For example:

• Practice sendKeys() on SauceDemo, OrangeHRM, and DemoQA.
• Practice getText() on dynamic applications and static pages.
• Practice isDisplayed() using loading screens and modal dialogs.
• Practice isEnabled() using forms with conditional validation.

Working with different UI implementations will prepare you for real enterprise projects where every application behaves differently.

SauceDemo (Exercises 1–9)

Website: https://www.saucedemo.com

SauceDemo is one of the best websites for practicing login forms, button interactions, and validation messages.

sendKeys() Practice

Exercise 1

• Enter a valid username.
• Verify the entered value using getAttribute("value").

Exercise 2

• Enter a valid password.
• Verify the password field accepts input.

Exercise 3

• Enter a username.
• Clear the textbox.
• Enter another username.

Exercise 4

• Enter invalid credentials.
• Attempt login.

Exercise 5

• Verify the username field is enabled before entering data.

Validation Practice

Exercise 6

• Verify the Login button is displayed.

Exercise 7

• Verify the Login button is enabled.

Exercise 8

• Click Login using invalid credentials.

Exercise 9

• Capture the displayed error message using getText().

OrangeHRM Demo (Exercises 10–18)

Website: https://opensource-demo.orangehrmlive.com

OrangeHRM provides enterprise-style forms that are excellent for learning input validation and dashboard verification.

Login Form Exercises

Exercise 10

• Enter username.
• Enter password.
• Login successfully.

Exercise 11

• Clear the password.
• Re-enter the password.
• Login again.

Exercise 12

• Enter an incorrect password.
• Capture the error message.

Dashboard Validation

Exercise 13

• Capture the page heading.

Exercise 14

• Validate the welcome message.

Input Validation

Exercise 15

• Retrieve placeholder values.

Exercise 16

• Verify entered values using getAttribute().

State Validation

Exercise 17

• Verify fields are enabled.

Exercise 18

• Verify dashboard elements are displayed.

The Internet (Exercises 19–27)

Website: https://the-internet.herokuapp.com

This website is ideal for practicing dynamic behavior and validation scenarios.

Login Page

Exercise 19

• Enter invalid credentials.

Exercise 20

• Click Login.

Exercise 21

• Capture the error message.

Successful Login

Exercise 22

• Login successfully.

Exercise 23

• Capture the success message.

Dynamic Loading

Exercise 24

• Verify the element is not displayed initially.

Exercise 25

• Click the Start button.

Exercise 26

• Wait until the element appears.

Exercise 27

• Validate the displayed text.

DemoQA (Exercises 28–39)

Website: https://demoqa.com

DemoQA provides many interactive UI controls useful for state validation.

Text Box Practice

Exercise 28

• Enter Full Name.

Exercise 29

• Clear the field.

Exercise 30

• Enter another name.

Radio Button Practice

Exercise 31

• Select a radio button.

Exercise 32

• Verify it is selected.

Checkbox Practice

Exercise 33

• Verify checkbox is unchecked.

Exercise 34

• Select checkbox.

Exercise 35

• Verify selection.

Dynamic Properties

Exercise 36

• Verify button is disabled initially.

Exercise 37

• Wait until enabled.

Exercise 38

• Click the button.

Exercise 39

• Validate successful interaction.

Rahul Shetty Automation Practice (Exercises 40–49)

Website: https://rahulshettyacademy.com/AutomationPractice/

This website is useful for practicing input fields, attributes, checkboxes, and dynamic controls.

Text Fields

Exercise 40

• Enter text into the search field.

Exercise 41

• Clear the field.

Exercise 42

• Enter another keyword.

Attribute Validation

Exercise 43

• Retrieve the href attribute.

Exercise 44

• Retrieve the class attribute.

Checkbox Validation

Exercise 45

• Select multiple checkboxes.

Exercise 46

• Verify each checkbox.

Radio Buttons

Exercise 47

• Select different radio buttons.

Value Validation

Exercise 48

• Validate entered values.

Exercise 49

• Compare getText() versus getAttribute("value").

Test Automation Practice Blogspot (Exercises 50–54)

Website: https://testautomationpractice.blogspot.com/

Exercise 50

• Verify the Submit button is disabled.

Exercise 51

• Enter mandatory values.

Exercise 52

• Verify Submit becomes enabled.

Exercise 53

• Submit the form.

Exercise 54

• Validate successful submission.

Advanced Validation Exercises (Exercises 55–59)

These exercises combine multiple WebElement methods into complete business scenarios.

Exercise 55

Validate delayed visibility using isDisplayed().

Exercise 56

Validate delayed enablement using isEnabled().

Exercise 57

Handle intermittent UI behavior without using Thread.sleep().

Exercise 58

Validate UI state using HTML attributes instead of visible text.

Exercise 59

Verify entered values using getAttribute("value") instead of getText().

Recommended Daily Practice Plan

If you're preparing for Selenium interviews, don't try to complete all exercises in one day. Instead, practice consistently.

Repeat the cycle until you can write the automation without referring to documentation.

Common Mistakes to Avoid

Many beginners struggle with WebElement methods because they misunderstand how Selenium interacts with HTML elements.

Avoid these common mistakes:

• Using getText() to retrieve values from input fields instead of getAttribute("value").
• Clicking elements without checking visibility.
• Entering text into disabled fields.
• Using Thread.sleep() unnecessarily.
• Ignoring element state before interaction.
• Hardcoding validation messages.
• Not clearing fields before entering new values.
• Assuming an element is clickable simply because it is visible.
• Writing duplicate WebElement interaction code instead of reusable helper methods.
• Ignoring exceptions such as ElementNotInteractableException and StaleElementReferenceException.

Best Practices

As your automation framework grows, following best practices becomes increasingly important.

• Always locate elements using stable locators.
• Verify visibility before interacting.
• Verify enablement before clicking or typing.
• Create reusable helper methods for common actions.
• Store expected validation messages externally whenever possible.
• Prefer explicit waits over hard waits.
• Keep assertions separate from action methods.
• Use descriptive method names in page objects.
• Validate business behavior, not just UI appearance.
• Design scripts that are readable and easy to maintain.

FAQs

1. Which WebElement methods are asked most frequently in Selenium interviews?

The most commonly asked methods are:

• sendKeys()
• click()
• getText()
• getAttribute()
• isDisplayed()
• isEnabled()
• isSelected()

Interviewers often ask candidates to explain the difference between these methods and demonstrate them using real examples.

2. What is the difference between getText() and getAttribute()?

getText() retrieves the visible text displayed on the webpage.

getAttribute() retrieves the value of an HTML attribute.

For example, text entered into an input field should be validated using:

element.getAttribute("value");

instead of getText().

3. Why should I verify isEnabled() before calling sendKeys()?

Typing into a disabled field results in automation failures.

Checking isEnabled() first makes the script safer and reduces flaky test failures.

4. Why is isDisplayed() important?

Applications frequently load elements dynamically.

Verifying visibility before interaction prevents common exceptions and improves script reliability.

5. Which websites are best for practicing WebElement methods?

Recommended practice websites include:

• SauceDemo
• OrangeHRM Demo
• DemoQA
• Rahul Shetty Automation Practice
• The Internet
• Test Automation Practice Blogspot
• OpenCart Demo

These sites cover nearly every WebElement interaction required in real-world automation projects.

6. How can I become confident with WebElement methods?

Practice each method repeatedly on multiple websites.

Instead of memorizing syntax, understand:

• when to use each method,
• what it returns,
• common failure scenarios,
• and how it behaves under different UI conditions.

This practical understanding is what interviewers evaluate.

Schema / Images / Internal Links (Suggested)

Recommended Schema

• Article
• FAQPage
• ItemList (for the structured exercise lists)

Suggested Images

1. WebElement Methods Overview

Alt text: selenium webelement methods sendkeys click gettext getattribute practice

Illustrates the relationship between the eight core WebElement methods.

2. Element State Validation Flow

Alt text: selenium isDisplayed isEnabled isSelected validation flow

Shows the recommended sequence:

Locate Element → Check Visibility → Check Enablement → Perform Action → Validate Result

3. Practice Website Map

Alt text: selenium practice websites for webelement methods

A visual guide showing which demo website is best suited for each exercise category.

4. Real-Time Automation Workflow

Alt text: selenium login validation workflow using webelement methods

Illustrates a complete automation flow combining:

• sendKeys()
• click()
• getText()
• getAttribute()
• state validation