Gamma Graphics Services (GGS) — Safe & Trusted NDT Testing
doesn’t have to be destructive or disruptive.
Gamma Graphics Services (GGS) has a better solution.
A painless testing process
performed by nationally trusted professionals
Safe for your staff and system, there is no radiation exposure risk
All piping, nested and suspended, can be tested
Zero holes in your piping insulation results in the preservation of the thermal barrier
Complete pipe circumference is tested, not just a single spot or side
No pipe is too small, accurate readings are collected on all sizes
Average test locations per day at your facility
Gamma Graphics Services (GGS)
Satisfy your Non-Destructive Testing (NDT) requirements with our service that has been trusted by end-users, contractors and consultants over 20 years.
Results of testing supports Mechanical Integrity and delivers data on your system that validates fitness for service and prioritizes areas that need attention. You will receive the information you need to meet today’s compliance requirements, mitigate risk, maintain mechanical integrity and control costs.
The NDT technology we use for pipe testing, Radiometric Profiling (RP), is the safest, most reliable method for process piping.
Watch the Video
Get the quality results you need
for your piping system.
Days on Site
Fit for Service
of tested locations
324 test locations
261 insulated / 63 bare
roof, engine rm, ceiling
Not to Code
2 insulated: 1″ sch 40
38 insulated / 0 bare
Pipe Wall Loss
4 locations 50%+
6 at 40%+; 21 at 30%+
8 insulated / 5 bare
Every day, we are in the field helping companies discover the truth about the health of their piping systems. Benefit from an integrity-focused approach to non-destructive testing that you can trust.
Make informed decisions with conclusive information you can count on. Our thorough, actionable reporting supports Mechanical Integrity and strengthens your PSM and RMP programs.
Benefit from the advanced capabilities of Radiometric Profiling, the NDT method that ensures comprehensive testing of your entire piping system. Gamma Graphics Services (GGS) uses technology that tests more locations in less time with no disruptions to your operations or system.
Our testing programs mutually support system operators, facility and safety managers, contractors and consultants. We serve industries that depend on process piping systems across the US and overseas, including refrigeration, petrochem, marine, and more.
Quoting is quick and easy.
Our flexible service options promise the same unique benefits for any system size or scope.
Request a Quote
You can depend on GGS.
GGS is committed to active participation and support of associations dedicated to innovation, education and advocacy.
We are an Active Contractor Member of the supplier management platforms ISNetworld and Avetta.
Our satisfied customers include maintenance and PSM managers, technicians, engineers, contractors and consultants of food and beverage and cold storage facilities across the US and internationally.
Refrigerating Engineers & Technicians Association
International Institute of Ammonia Refrigeration
UW Madison Industrial Refrigeration Consortium
International Association of Refrigerated Warehouses, Core Partner of GCCA
What is Graphic User Interface (GUI) Testing
Graphic User Interface Testing (GUI) testing is the process of ensuring proper functionality of the graphical user interface (GUI) for a specific application. This involves making sure it behaves in accordance with its requirements and works as expected across the range of supported platforms and devices.
Download as PDF
Why is GUI Testing Important?
Modern computer systems are generally designed using the ‘layered architecture approach’:
This means that the core functionality of the system is contained within the “business logic” layer as a series of discrete but connected business components. They are responsible for taking information from the various user interfaces, performing calculations and transactions on the database layer and then presenting the results back to the user interface.
In an ideal world, the presentation layer would be very simple and with sufficient unit tests and other code-level tests (e.g. API testing if there are external application program interfaces (APIs)) you would have complete code coverage by just testing the business and data layers. Unfortunately, reality is never quite that simple and you often will need to test the Graphic User Interface (GUI) to cover all of the functionality and have complete test coverage. That is where GUI testing comes in.
Testing of the user interface (called a GUI when it’s graphics based vs. a simple text interface) is called GUI testing and allows you to test the functionality from a user’s perspective. Sometimes the internal functions of the system work correctly but the user interface doesn’t let a user perform the actions. Other types of testing would miss this failure, so GUI testing is good to have in addition to the other types.
What Types of GUI Testing Exist?
There are two main types of GUI testing available:
- Analog Recording
- Object Based
This is often what people associate with GUI testing tools. With analog recording, the testing tool basically captures specific mouse clicks, keyboard presses and other user actions and then simply stores them in a file for playback. For example, it might record that a user left-clicked at position X = 500 pixels, Y = 400 pixels or typed the word “Search” in a box and pressed the [ENTER] key on their keyboard.
Relative Analog Recording
Relative analog recording is one type of analog recording where the positions of interaction events are recorded in relation to the top-left corner of the application’s window:
Absolute Analog Recording
Absolute analog recording is the other main type of analog recording. Here, the positions of events are recorded relative to the top-left corner of the system screen.
The main benefits of analog recording are:
- It works with virtually all applications regardless of the technology or platform used. Nothing is required of the application developer to make it testable.
- It is quick to write such tests and as long as the GUI is stable and you can guarantee the screen resolution and window position, it can be a good way to test older applications that are not under active development
However, there are several major drawbacks to analog testing:
- The tests are sensitive to changes in the screen resolution, object position the size of windows, and scrollbars. That means you need to spend extra effort making sure you can standardize such factors.
- The tests are not intelligent; they don’t look for specific objects (e.g. the Submit button) but are just a series of recorded gestures. So if you change the UI (e.g. move a button, or change a button to a hyperlink) in any way, the tests will need be rewritten. For this reason, analog tests are referred to as “brittle”.
- When analog tests perform an action, there is very limited feedback since the testing tool is just clicking at a coordinate or sending a keypress — the tool does not understand if the application worked correctly, making human validation essential.
Object Based Recording
When you use object based recording, the testing tool is able to connect programmatically to the application being tested and “see” each of the individual user interface components (a button, a text box, a hyperlink) as separate entities and is able to perform operations (click, enter text) and read the state (is it enabled, what is the label text, what is the current value) reliably regardless of where that object is on the screen.
The main benefits of object based learning are:
- The test is more robust and does not reply on the UI objects being in a certain position on the screen or being in the top-most window, etc.
- The test will give immediate feedback when it fails, for example that a button could not be clicked or that a verification test on a label did not match the expected text.
- The tests will be less “brittle” and require less rework as the application changes. This is especially important for a system under active development that is undergoing more UX changes. For older, legacy applications this may be less important.
However, there are some drawbacks to this approach:
- The testing tool needs to have specific support for each of the technologies being used in the application. For example, if you have a web page that contains a Java applet and a Flash application embedded, you would need to have a testing tool that understands all three technologies (Java UI Toolkit, Flex Runtime and the HTML DOM).
- For some technologies (e.g. Flex, Flash) the developers need to add instrumentation to their code so that the testing tools able to “see” the UI objects. If you don’t have access to the source code of the application, then it’s not possible to test it.
- Writing the tests may take more skill than simply clicking and pointing, you need to be able to use Spy and inspection tools to navigate the object hierarchy and interact with the right UI elements.
So Which Should I use?
So the best practices are to use Object Based recording that is more robust and reliable where possible and then use Analog recording to “fill in the gaps” where nothing else works.
What are the Challenges with GUI Testing?
Regardless of the approach taken, there are some general challenges with GUI testing:
- Repeatability – Unlike code libraries and APIs which generally are designed to be fixed, user interfaces of applications tend to change significantly between versions. So when testing a user interface, you may need to refactor large sections of your recorded test script to make it work correctly with the updated version.
- Technology Support – Applications may be written using a variety of technologies (e.g. Java or .NET) and may use a variety of different control libraries (Java AWT vs. Java SWT). Not all control libraries are as easy to test and specific testing tools may work better for some libraries than others.
- Stability of Objects – When developers write an application, their choices can determine how easy an application’s GUI is to test. If the objects in an application have a different ID value every time you open a Window that makes it much harder.
- Instrumentation – Some technologies are designed to be tested without any changes made to the source of the application, however in some cases, the developer needs to add special code (called instrumentation) or compile with a specific library to enable it to be tested. If you don’t have access to the source code in such cases, that limits the testing options.
What are the Best Practices for GUI Testing?
1. Upfront Technology Assessment
It is generally recommended that you perform an early assessment of the technology that the application uses and see which UI controls and widgets are being used. In many cases you will have some non-standard UI controls and elements that testing tools may struggle to interact with. You need to do this assessment upfront before selecting a tool.
For example, on a sample Microsoft Windows system, the following different automated testing technologies are available:
Each technology that your application uses may require a different testing library that can understand how to recognize the UI objects, for example:
- Microsoft Active Accessibility (MSAA). This is an API developed by Microsoft originally designed for visually impaired users to enable screen-readers and other assistive technologies to allow them to see the screen. It was adopted by testing tools as a reliable way to see objects inside a GUI
- Microsoft UIAutomation. This is the replacement API developed by Microsoft in Windows Vista (and later) to replace MSAA and allow testing tools to connect to objects in the Windows GUI and perform operations on those objects.
- Java Reflection. When you have applications running in a Java VM that use either the AWT or Swing GUI libraries, the testing tool needs to connect to the running Java VM and use the reflection API to be able to understand the objects that are in use and test them.
- .NET Reflection. When you have applications running in the Microsoft .NET CLR that use are 100% using managed code, the testing tool can connect to the CLR and use the .NET reflection API to get more precise information than would be provided by just MSAA or UIAutomation.
- Selenium WebDriver. When you are looking to send commands to a web browser and to inspect the web browser Document Object Model (DOM), the WebDriver API is available on most browsers to give programmatic access. However it does not let you record user actions.
- Web Browser Plugins. Most (but not all) web browsers support a plug-in architecture that lets testing tools interact with the loaded web page, inspect the browser DOM, but unlike WebDriver, also record user interactions
- FlexLoader. This technology lets you load a compiled Flex/AIR/Flash application inside a testing container so that the objects in the application can be tested without needing to recompile the source code.
- FlexBuilder. If you are testing a Flex/AIR/Flash application and have access to the source code, this API is a form of instrumentation that can be compiled into your application and then the application can be tested without any special loading techniques.
- Selendroid – This is the original testing API provided by Google to test Android mobile devices. It has now been replaced by Android uiautomator
- Apple XCUITest – This is the newest testing API provided by Apple for iOS devices. It was introduced in Xcode 7 and includes significantly better debugging than UIAutomation and includes the ability to record user events.
- Android uiautomator – This is the current testing API used to test Android applications, it is available on Android API >= 17 and is used by most modern mobile testing tools.
2. Be Realistic About What to Automate
In theory you could automate 100% of your manual tests and replace with automated GUI tests. However, that is not always a good idea! Automated tests take longer to write than manual test since they have to be very specific to each object on the page. With experienced manual testers, you can write very high level instructions (“test that you can reserve a flight”) and they can test lots of combinations and follow their intuition much more quickly than you can record all the different automated tests.
However, computers are really good at automated mundane tasks. For example, testing that you can click on every possible page in the application and do it on all flavors of the operating system, web browser and screen resolution would take forever for a human, but would take an automated testing tool no time at all. Similarly, testing the login page with 1,000+ different login/password combinations is much more efficient for a computer to do.
So let’s say that we have decided to automate 20% of our test cases, great! There is only one problem — 20% means 20% of your test cases. But which 20% you may ask?
How about the 20% of test cases used most often, that have the most impact on customer satisfaction, and that chew up around 70% of the test team’s time? The 20% of test cases that will reduce overall test time by the greatest factor, freeing the team for other tasks. That might be a good place to start.
These are the test cases that you dedicate many hours performing, every day, every release, every build. These are the test cases that you dread. It is like slamming your head into a brick wall – the outcome never seems to change. It is monotonous, it is boring, but, yes, it is very necessary. These test cases are critical because most of your clients use these paths to successfully complete tasks. Therefore, these are the tasks that pay the company and the test team to exist. These test cases are tedious but important.
3. Avoid the Perfection Trap
Sometimes when automating an application, you will meet a special UI control that is not handled by the testing tool that you are using (or maybe is not handled by any testing tool that you have tried). If you look for perfection, so that every single possible object on the page can be tested automatically you may end up frustrated, wasting time and possibly resulting in abandonment of the entire automation effort.
The solution is to be creative, if you can use analog recording for that one control, then maybe that is the best solution. Sometimes you may need to use a combination of techniques to simulate the user action, using special keystrokes to avoid the button in question. The goal is to improve your test coverage and make sure you find problems that need fixing, if that involves some creative solutions that are not “perfect”, so be it, the overall goal is still being met.
What Features Should I Look for in a GUI Testing Tool?
Obviously the first answer is to choose a tool that can automate the specific technologies you’re testing, otherwise your automation is doomed to fail. Secondly you should choose a tool that has some of the following characteristics:
- Good IDE that makes it easy for your automation engineers to write tests, make changes, find issues and be able to deploy the tests on all the environments you need to test.
- A tool that is well supported by the manufacturer and is keeping up to date with new web browsers, operating systems and technologies that you will need to test in the future. Just because you used to write your application on Windows 3.1 using Delphi doesn’t mean it will be that way forever!
- An object abstraction layer so that your test analysts can write the tests in the way most natural for them and your automation engineers can create objects that point to physical items in the application that will be robust and not change every time you resort a grid or add data to the system.
- Support for data-driven testing since as we have discussed, one of the big benefits of automation is the ability to run the same test thousands of times with different sets of data.
Rapise from Inflectra is a great tool that meets these criteria, is very easy to use, covers a wide range of technologies (web, desktop, mobile and APIs) and is relatively affordable:
However whichever tool(s) you choose to use, make sure that your testers can try them out for at least 30 days on a real project to make sure they will work for your team and the applications you are testing.
Try Rapise free for 30 days, no credit cards, no contracts
Start My Free Trial
And if you have any questions, please email or call us at +1 (202) 558-6885
SpiraTest combines test management, requirements traceability & bug-tracking
SpiraTeam brings your teams together, managing the entire application lifecycle
SpiraPlan lets you manage your programs and portfolio of projects like never before
Orchestrates your automated regression testing, functional, load and performance
The ultimate test automation platform for web, mobile, and desktop applications
The help desk system, designed specifically for software support teams
Cloud hosted, secure source code management — Git and Subversion
Exploratory testing capture tool that automatically records your testing activity
Let us deal with the IT pain so you don’t have to. Or use on-premise if you prefer.
See how Inflectra tools work with you, whatever your role
Our customers work in every industry imaginable. From financial services to healthcare and biotech to government and defense and more, we work with our customers to address their specific needs.
Our products do not enforce a methodology on you, instead they let you work your way. Whether you work in
Kanban and Lean,
or Scaled Agile
Inflectra can help.
If you want to learn more about application delivery, testing, and more take a look at our
Our suite of Accelerators speed up your deployment and adoption of our products,
increasing your return on investment and reducing the cost of ownership.
We collaborate with a wide range of teams to bring our customers a range of
training, and consultation),
complimentary technologies, and
specialized tools for specific industries.
Learn how different
have benefited from using Inflectra products
to manage their software testing and application develooment.
See how Inflectra tools work with you, whatever your role
Outstanding support is the foundation of our company. We make support a priority over all other work. Take a look at our support policy.
Discover great tips, discussions, and technical solutions from fellow customers and Inflectra’s technical experts.
If you can’t find the answer you’re looking for, please get in touch with us: over email, phone, or online.
Browse our guides and manuals for all our products and addons.
Our tools integrate with over 50 different applications to help you work smarter and faster.
Add-Ons and Downloads
We offer a wide range of extensions and add-ons to do everything from hooking up to Google Sheets, to your IDE, to unit test frameworks.
Review the specific requirements needed to run our applications.
We are constantly creating new videos to help customers learn about our products, including through in depth webinars, all freely available along with a wide selection of presentations.
We provide a number of resources to help customers learn how to get the most out of our products, with free online resources, virtual classrooms, and face to face.
Read about Inflectra, our manifesto, and values.
Meet our incredible customers who are building awesome things,
and our leadership team that are committed to building a great company.
Take a look at our press releases, company news, and product announcements.
If you are looking for our logos, check out our Media Kit.
The Inflectra Blog contains articles on all aspects of the software lifecycle.
In addition we have whitepapers,
background articles, videos and
presentations to help get you started.
Events are a big part of our awesome customer service. They are a chance to learn more about us, our products, and how to level up your skills with our tools.
We partner with educational institutions
and individuals all over the world. We are also a great place to work and encourage you to explore joining our team.
Please contact us with your questions, feedback, comments, or suggestions. We’ll get back to you as soon as possible.
When you need additional assistance (be it training, consulting, or integration services) our global certified solution provider partner network is ready to help.
At Inflectra, we are fully committed to provide our customers with the very best products and customer service.
Check out some of our recent awards.
We want to help developers extend and customize our tools to fit in with their needs. We provide robust APIs, sample code, and open source projects.
Abrarov, R. D. GUI testing / R. D. Abrarov, V. O. Pak. — Text: direct // Technique. Technologies. Engineering. — 2017. — No. 3.1 (5.1). — P. 3-4. — URL: https://moluch.ru/th/8/archive/62/2630/ (date of access: 01/27/2023).
What is a GUI? nine0014
There are two types of interfaces for computer applications.
A command line interface where you type text and the computer responds to that command.
GUI stands for Graphical User Interface, where you interact with the computer using images rather than text.
The following are the GUI elements that can be used to interact between the user and the application:
GUI testing is a test of specified elements.
What is GUI testing?
GUI testing is the process of testing the system’s graphical user interface from the application under test. GUI testing involves testing screens with controls such as menu buttons, icons and all kinds of bars — toolbars, menu bars, dialog boxes, etc.
The GUI is what the user sees. The user does not see the source code. The interface is visible to the user. Particular emphasis is placed on the design of the structure, the images that they work properly or not.
In the above example, if we have to do GUI testing, first make sure that the images should be fully visible in different browsers.
Also, the links are available and the button should work when clicked.
Also, if the user resizes the screen, neither the image nor the content should shrink or crop or overlap.
Need to test GUI
Now, the basic concept of GUI testing is clear. A few questions:
Why GUI testing?
— Is it really necessary?
Is it enough to test the functionality and logic of the application?
To get an answer, think like a user, not like a tester. It is the user interface of the application that decided that the user will continue to use the application or not.
The average user first observes the design and appearance of the application/software and how easy it is to understand its interface. If the user does not feel comfortable with the application’s interface or find it difficult to understand that he will never use this application again. That’s why, the GUI is a matter of concern, and proper testing should be done in order to make sure the GUI is bug-free.
What are you testing in the testing GUI?
The following list will provide detailed GUI testing.
Check all GUI elements for size, position, width, length and accept characters or numbers. For example, you should be able to contribute to the relevant input fields.
Make sure you can execute the intended functionality of the application using the GUI
Check Error messages are displayed correctly
Check if the different areas on the screen are clearly demarcated
Check the font used in the reader app
Check the alignment of the text itself
Check font color and warning messages aesthetically
Make sure images have good transparency
Make sure the images are properly aligned
Check the location of GUI elements for different screen resolutions.
GUI test approach
GUI testing can be done in three ways:
In this approach, graphical screens are manually tested by testers according to the requirements specified in the business requirements document.
Recording and playback
GUI testing can be done with automation tools. This is done in 2 parts. During recording, the test steps are recorded by the automation tool. During playback, the recorded test steps are executed in the test application.
Model based on testing
The model is a graphical description of the behavior of the system. This will help us understand and predict the behavior of the system. Models help in generating efficient tests using system requirements. These needs must be considered for this model-based testing:
— Build a model
Determine the initial data for the model
Calculate the expected output for the model
— Run tests
Compare actual output with expected output
Decision on further actions on the model
GUI testing mainly related to
- Testing the size, position, width and height of elements.
- Testing to get error messages that are displayed on the screen.
- Testing different sections of the screen.
- Screen testing in different resolutions by zooming in and out like 640×480, 600×800 etc.
- Checking text alignment and other elements like icons, buttons, etc. are in the right place or not.
- Font color testing.
- Testing the color of error and warning messages.
Testing whether the image has good transparency or not.
- Image alignment check.
- Spelling testing.
- Testing interface is attractive or not.
- Image size testing.
- Testing the headings to see if it’s aligned correctly or not.
- Hyperlink color testing.
Testing the font whether it is readable or not.
Problems in GUI testing
The most common problem to come up with doing regression testing is that the application’s GUI changes frequently. It’s very difficult to check and determine if it’s a problem or an accessory. The problem shows up when you don’t have any documentation regarding GUI changes.
The success of a software product is highly dependent on how the GUI interacts with the user and the ease of use of its various features. Thus, GUI testing is very important. Manual GUI testing can be sometimes repetitive and boring. Automation is highly recommended for GUI testing.
- GUI Testing: Complete Guide. [Electronic resource]. — Access mode: http://www.guru99.com/gui-testing.html (accessed 25 May 2017).
- Software testing as an integral part of software quality. Pak V. O., Abrarov R. D., Kuryazov D. A. Software testing as an integral part of software quality // Young scientist. — 2016. — No. 9.5. — S. 29-32.
- P. Ammann and J. Offutt, Introduction to Software Testing. Cambridge University Press, 08.
- R. Patton, Software Testing. Sams Publishing, 2001.
W. E. Perry, Effective Methods for Software Testing. Wiley Publishing, 2006.
- A. Spillner, T. Linz, T. Rossner, M. Winter: Test Management: A Study Guide for the Certified Test Exam ISTQB Advanced Level. Rocky Nook, 2007.
- R. Patton, Software testing. Indianapolis, Ind.: Sams, 2001.
Basic terms (automatically generated) : GUI, GUI, testing, GUI, none, user, image, expected output, manual testing, good transparency. nine0009
interface and game control | Journal article…
GUI GUI testing. Testing GUI involves testing screens with controls such as menu buttons, icons and all kinds of bars — toolbars, menu bars, dialog boxes, etc.
| Journal article. ..
GUI GUI testing. GUI means graphical user interface where you interact with the computer using images , not text. The following are GUI items…
Graphic user interface is a big topic…
GUI GUI testing. GUI means graphical user interface where you interact with the computer using images , not text. Particular emphasis is placed on the design of the structure, images…
Analysis and comparison of control methods during…
GUI GUI testing. Testing GUI is the process of testing the graphic user interface of the system from the application under test.
Development of a module for the formation of student documents…
Testing graphic interface ( GUI testing). Testing GUI is the process of testing the graphic user interface of the system from the application under test.
INTERFACE — use of interfaces ; — IMPLEMENTS…
GUI GUI testing. There are two types of interfaces for computer applications. Command line interface where you type text and the computer responding to this command.
Working with GUI elements
using an example application…
GUI GUI testing. Testing GUI involves testing screens with controls such as menu buttons, icons and all kinds of bars — toolbars, menu bars, dialog boxes, etc. nine0009
Development of an exercise visualization software application…
GUI GUI testing.
In addition, if the user changed the screen size, neither the image nor the content should be reduced or cropped or overlapped.
Using Python to automate…
GUI GUI testing.
GUI means graphical user interface where you interact with the computer using images , not text.
User interface testing — QA evolution
User interface testing
User interface testing. Graphical user interface (GUI) is a kind of user interface in which the interface elements (menus, buttons, icons, lists, etc.) presented to the user on the display are executed in the form of graphic images. nine0009
The general view of the application as a whole and, separately, the forms located on the page are checked.
- Element appearance when the browser window is reduced + scrolling appears
- Correct spelling of text + text must be aligned
- Correct movement of focus in a window (Tab / Tab+Shift)
- Selected elements are highlighted
- Fixed fields look the same and different from editable fields
- It is advisable not to use double click
- Checking for necessary notifications
- Design unification (color, font, size)
- Should have tooltips if needed
- Changing the appearance of an element when hovering over it
- If the forms are duplicated, then the names must be the same
Additional checks for web forms
- Location next to the corresponding text
- Button switching via keypad
- Set checkbox with click and space
- Location next to the corresponding text
Drop down lists
- Must have a scroll function
- Must be alphabetical (if text), ascending (if numeric)
- If an element has been selected, it must be at the top or indicated that it is selected
- Window Center
GUI (Graphical User Interface) Testing — testing of the graphical user interface. A graphical user interface is an interface in which a user interacts with a computer using graphical representations. nine0009
Basic GUI elements:
- window (browser window, dialog box, modal window, floating window)
- menu (main, pop-up, context, system)
- widgets / controls / controls (accordion, button, radio button, checkbox, icon (icon), list, toolbar, tree, scrollbar, slider, status bar, tooltip (hint), etc.)
- interaction elements: mouse cursor, text cursor, pointer (“palm”), drag cursor, etc.
GUI check highlights:
- position, size, color, width, length of elements; possibility to enter letters or numbers
- whether the functionality of the application is implemented using graphic elements
- placement of all error messages, notifications (as well as the font, color, size, position and spelling of the text)
- Is the font used readable
- whether the cursor switches from text to pointer when hovering over active elements, whether selected elements are highlighted
- align text and shapes
- image quality
- check the location and display of all elements at different screen resolutions, as well as when resizing the browser window (check if a scroll appears)
- check the text for spelling, punctuation errors
- whether tooltips appear (if needed)
- design unification (colors, fonts, message text, button names, etc.