Generic Coding Standards for Automation

Use SoftAssertion instead of multiple asserting statements. 
ReadMe should have all the detailed steps on how to run the Automation Suite. 
Classes should not have too many "static" imports
"private" and "final" methods that don't access instance data should be "static"
"Thread.sleep" should not be used in tests
Duplication of assertion should be avoided
The functionality is good for the users of the code.
All UI changes are sensible and look good.
Avoid using numbers inside the Xpath.
All parallel programming is done safely.
The code isn’t more complex than it needs to be.
The author isn’t implementing things they might need in the future,
but don’t know they need now.
The developer used clear names for everything.
Comments are clear and useful, and mostly explain why instead of what.
The code is appropriately documented.
The code conforms to the style guides.
Take a screenshot of the failed investigation.
Refactor to make sure that no duplication is tolerated
Redundant parenthesis
Constants should always be all-uppercase, with underscores to separate words
Use of Constant class and not specific classes

Java Standards for Test Script Design

Java coding standards for automation testing are similar to general coding standards, with some additional considerations specific to automation testing. Here are some general coding standards for automation testing using Java:

Naming Conventions:
Use meaningful names for classes, methods, and variables. Use CamelCase for class names, and start with a lowercase letter for variable and method names. Use descriptive names that accurately reflect their purpose.
Code Formatting:
Follow a consistent code formatting style, such as the one recommended by Oracle. Use consistent indentation, avoid excessive line length, and add comments where necessary to explain complex code.
Error Handling:
Handle exceptions properly in your code. Use try-catch blocks to handle exceptions, and add descriptive error messages that help you understand what went wrong when the code fails.
Modularity:
Write code that is modular, reusable, and maintainable. Break up your code into smaller, reusable functions, and create classes that encapsulate specific functionality. Use inheritance and polymorphism to create a more modular and maintainable codebase.
Test Design:
Write code that is easy to test. Use design patterns like Page Object Model (POM) to create code that is easy to test, maintain, and update. Write test cases that are independent, atomic, and repeatable.
Assertions:
Use assertions in your test code to validate that the application under test is behaving as expected. Use descriptive error messages in your assertions to help you understand what went wrong when the code fails.
Code Review:
Have a code review process in place to ensure that your code follows established standards, is maintainable, and is easy to test. Review your code with your team and get feedback to improve your coding practices.

By following these Java coding standards for automation testing, you can create more maintainable, reusable, and testable code, which can lead to more efficient and effective automation testing.

How to convert List to array and array to list?

Click here for Answer

General rules

Follow standard conventions.
Keep it simple stupid. Simpler is always better.
Reduce complexity as much as possible.
Boy scout rule. Leave the campground cleaner than you found it.
Always find root cause. Always look for the root cause of a problem.

Design rules

Keep configurable data at high levels.
Prefer polymorphism to if/else or switch/case.
Separate multi-threading code.
Prevent over-configurability.
Use dependency injection.
Follow Law of Demeter. A class should know only its direct dependencies.

Understandability tips

Be consistent. If you do something a certain way,
do all similar things in the same way.
Use explanatory variables.
Encapsulate boundary conditions.
Boundary conditions are hard to keep track of.
Put the processing for them in one place.
Prefer dedicated value objects to primitive type.
Avoid logical dependency.
Don't write methods which works correctly depending on something
else in the same class.
Avoid negative conditionals.

How to run Java Application as Docker Image? Click for details