If you’re planning on releasing software, a mobile app, or website on the international market, it’s important to make sure that your target market in each country will understand your localized version with Localization Testing. Localization Testing allows you to test how accurate your new version is, how well your content has been adapted, and whether or not it displays correctly in the interface.
Without Localization Testing, even a well-translated release might leave you with confused, unhappy customers. Incorrect sentences, cropped lines and cultural faux-pas can lead to a negative impression of your website, software, or app.
This article will cover how to carry out Localization Testing, how to automate Localization Testing, and which tools to use in the testing process.
What is Localization Quality Assurance? What does it involve? And why is it necessary?
Localization Quality Assurance (LQA) is the comprehensive testing of a translated product to ensure it meets the linguistic, cultural, and technical expectations of users in different countries.
The goal of the testing process is to find and fix mistakes that could prevent people from viewing your software, app, or website as naturally as people experienced the original.
Quality Assurance testers check:
- how accurate the localization is.
- how well the content has been adapted to the local culture.
- how well the project works on a technical level.
This ensures the quality of the localized application, software or site and makes it easy for audiences across different regions to use and understand.
What to check during Localization Testing?
The main elements of LQA that should be prioritized during testing are:
- the language, to test how accurate and clear the new version is.
- the user interface, to see how well the text and elements display.
- user experience, to see how easy and intuitive the software, game, or website is to use.
The goal of Localization Testing is to ensure that:
- content is displayed in the correct language.
- the localization doesn’t distract or confuse the user.
- the code and fonts work correctly.
There can be other testing requirements—it all depends on what you’re working on.
What checks are carried out during Localization Testing?
- Linguistic testing
Goal: to ensure that the text has been translated accurately and correctly, while maintaining the style and meaning of the original.
What to look out for:
- Grammar and spelling. It’s important to check that all grammatical constructions are correct and ensure that there are no typos. Even small mistakes can negatively affect user experience.
- Translation accuracy. The localization should accurately convey the meaning of the original. It’s important to avoid too literal of a translation, as this can skew the meaning of the content. If the text has idioms or expressions, equivalents should be found in the target language that will be understood by the target audience.
- Style. The style should match the original and be appropriate for the target audience. For example, a gaming app should sound engaging and exciting, whereas business software should be more formal.
- Cultural adaptation
Goal: to ensure the content is relevant and appropriate for users from different cultures.
What we check:
- Traditions and preferences. This is where we need to take local traditions and cultural norms into account. What’s acceptable in one country may be unclear or even offensive in another.
- Symbols and imagery. Some gestures, symbols, and colors can have different meanings in different cultures. For example, the “OK” gesture (with the thumb and index finger together) is considered offensive in some countries.
- Names and characters. During this stage, the characters’ names, appearances, and behavior undergo testing to ensure they are clear and appropriate in the local culture.
- Technical checks
Goal: to ensure that the product works correctly and looks good on different devices and platforms.
What to look out for:
- Formatting and units of measurement. The display of dates, times, currencies, and units of measurements all undergo testing at this stage. For example, using the date format “date/month/year” in one country and “month/day/year” in another.
- Text display. It’s important to ensure during testing that the text does not cut off or overlap with other software interface elements. This is especially important for localizations where sentences can be longer in translation than in the original. For example, localizations into German or Russian can take up more space than an English text, so this must be taken into account when planning the interface.
- Fonts and special characters. It’s important to test that all special characters are displayed correctly, especially in cases like Chinese or Arabic which use non-standard alphabets.
- Platforms. There should be no difference in performance across different devices, including PC, tablets, and smartphones with varying operating systems.
The different stages of LQA
We’ll now walk you through the standard LQA testing process we use at Inlingo.
1. Preparation
This is the stage where we determine the main parameters of the project before testing:
- Choosing the languages. We decide which languages we’ll use for localization, taking into account the target market and audience.
- Estimating the volume of work. The next stage of the process is to analyze the amount of text and content that needs to be translated and checked.
- Assembling a team. Finally, we put together a team of linguists and Quality Assurance testers who speak the target languages and understand the specificities of the project. For example, if we’re planning to release a mobile app about football in Spain and Japan, we need to put together a team that has good knowledge of Spanish and Japanese. It’s also important that they understand football terminology and are familiar with these countries’ cultures.
2. Testing
After preparing the team, it’s Localization Testing time.
Here’s what we need to check:
- Linguistic accuracy. We ensure that the localization is correct, that there are no grammatical or spelling mistakes, and that the style and tone of the original have been maintained.
- The interface. We ensure that the text is displayed correctly in the interface, doesn’t cut off, and doesn’t extend beyond interface elements. We also test that fonts are legible and symbols are correct.
- Functionality. We test that all functions work correctly in the localized versions. We make sure that all buttons, links, and forms function the way they should and that the product meets user expectations.
3. Correcting errors
Once the testing stage is over, we create a report that lists any problems we identified and how to resolve them.
This step includes the following:
- Error analysis. Here we classify mistakes based on type—linguistic, technical, and functional—and decide which ones should be fixed first.
- Revisions. Our linguists make corrections, while the client’s developers fix any technical problems with the interface and the code.
- Change documentation. We record all corrections that have been made to track progress and avoid repeated mistakes.
4. Regression testing
Finally, we carry out another round of testing to make sure that all problems have been resolved and no other issues have appeared.
During this stage, the following undergo testing:
- The text. We make sure that the corrected texts are now accurate and error-free.
- The interface. We test that the changes that have been made don’t have a negative effect on how UI elements are displayed and that everything looks the way it should.
- Functionality. We ensure that the product is stable and that the new corrections haven’t caused any crashes in other parts of the system.
Automated Localization Testing
Automation makes the localization process faster and easier.
What testing processes can be automated?
- Checking the length of the text. The computer checks if the text is too long for the buttons.
- Searching for untranslated sentences. The program finds any sections that haven’t been translated.
- Checking numbers and dates. The program verifies that all dates and numbers are displayed correctly.
- Basic functions. Some simple testing can show if the main buttons and menu work properly.
How do you automate the QA process?
Before beginning, you need to decide:
- which parts of the program the computer will check.
- which localizations should have automated testing.
- what testing will be automated and what testing will be done manually.
For example, 70% of testing for English and German can be automated, but only 50% of testing can be automated for Japanese (as the latter is more complex).
How do you make automated tests?
- Make test scripts. We see how the program should work. Then we write down the steps of what to do and what should happen.
- Make simple checks. We make simple tests that check if the program even works at all. They don’t test for complicated errors—they just flag up obvious issues.
- Choose your tools. Selenium will work for websites, while Appium is good for mobile app. The final stage of the process is to set up a system that will launch our tests automatically every day.
Who is responsible for this?
An automation team has members with a range of skill sets:
- The manager is in charge of the entire process.
- The test creators figure out what to check and how to do it.
- The programmers write code for the automated tests.
- The testers check everything that the computer can’t.
Testers don’t need to know the language perfectly. All testers need is to know what to look out for in a language.
What testing processes can’t be automated?
Computers are great, but they can’t replace humans entirely. They don’t understand if a joke will work in another country. They won’t pick up on any linguistic oddities. They can’t tell how easy it is to use a certain software. Therefore, some things still have to be entrusted to testers for manual testing.
The best tools to use
Translation management systems (TMS)
A translation management system (TMS) is a program which serves as a bridge between everything involved in translation and testing. It allows for:
- All your translations to be in one place. Localizers don’t need to hunt through different folders for files.
- A unified style. The entire team can use the same terms and expressions.
- Automated checks. The system can find mistakes and inconsistencies itself.
Some TMS examples are Crowdin, Phrase, Smartcat.
Programs for automated checks
There are tools that can help you find and correct mistakes automatically:
- Spelling and grammar checks. These can find typos and incorrect word forms.
- Variable and tag checks. These help to ensure that you have all the technical elements you need.
- Extra space and symbol checks. These keep your text neat.
Some examples of these tools are Xbench, Verifika, QA Distiller.
Emulators and testers
- System emulators. These show how your product will look on different phones, tablets, and computers.
Some examples of emulators are Android Studio Emulator, iOS Simulator.
- Tools for interface checks. These help to find places where the text cuts off or isn’t displayed correctly.
Some examples of these tools are Sikuli, Screenshot Validator.
Next are some checklists for software and website testing.
Software testing checklist
- Language
- Make sure that the interface loads in the desired language.
- Check that the localization is accurate and that there are no mistakes.
- Cultural and regional aspects
- Check that date, time, and currency formats meet local standards.
- Make sure that any symbols and images are culturally appropriate for the region.
- User interface
- Check that the text doesn’t cut off or overlap with other interface elements.
- Make sure that fonts display correctly for every language.
- Check that hotkeys work with different keyboard layouts.
- Functionality
- Make sure that all features work as intended.
- Check that all lines of text load and display correctly.
- Make sure that placeholders and variables display correctly.
Website testing checklist
- Content
- Make sure that all texts have been translated correctly and will be easy for the user to understand.
- Check that keywords and meta tags have been adapted for local SEO.
- Functionality
- Check that all links function and lead to the correct pages.
- Make sure that forms and edit boxes accept data in the new language without any issues.
- If you have an online shop, test the purchasing process from beginning to end.
- User interface
- Make sure that the website displays correctly on different devices and screens.
- Ensure that the text doesn’t cut off and isn’t difficult to read.
- Decide how effective calls to action (CTAs) are in the localized version.
- Cultural considerations
- Check that any images and graphics are suitable for the local audience.
- Make sure that the color scheme doesn’t have any negative associations.
- Check that the content complies with local laws and ethical norms.
- The technical side
- Make sure that the website loads quickly in the target region.
- Check that it’s compatible with popular browsers in the country.
- Make sure that the website complies with data protection and security standards.
A real-life example of Localization Testing
Let’s have a look at an Inlingo LQA case. The product is a mobile game called Shadow Fight 3. It’s a popular fighting gaming with a complex plot and a wealth of gaming content.
Project goal:
- Localize the game into 14 languages.
- Adapt the content for various cultures.
- Ensure the game works correctly on different devices and platforms.
Stages of work:
- Preparation
- We assessed the amount of text and the complexity of the translation for every localization.
- We put together teams of native speaker translators and testers for every country.
- Linguistic testing
- We checked that the localization was accurate and maintained the meaning of the original.
- We adapted the dialogue style and tone of the game to comply with any cultural considerations for the target country.
- We unified the terminology across all sections of the game.
- Cultural adaptation
- We adapted jokes, idioms, and references for every region.
- We made sure that the content complied with local laws and norms.
- Technical testing
- We checked that the text displayed correctly on different devices to avoid any sections cutting off or overlaying.
- We solved issues with long words in some localizations by adapting the interface and rephrasing the text.
- We made sure special characters and fonts displayed correctly, especially for writing systems which use characters.
- Correcting mistakes and the second round of testing
- We recorded all mistakes we had come across and made recommendations as to how to resolve them.
- We made necessary corrections with the developers.
- We carried out regression testing to check stability after corrections were made.
Results:
- We successfully created 14 localizations, including German, Japanese, Spanish, Chinese, and Arabic.
- We received positive player feedback praising the localization for how natural and smooth it was.
- We increased downloads and active users in new regions.
Are you planning to release your product on the international market? Put your project’s Localization Testing in the capable hands of our team at Inlingo. We’ll test the adapted version of your software, app, or website and have it ready to meet the world in no time.