Skip to content

Free, open-source macOS cleaner. CleanMyMac alternative with zero telemetry. Native SwiftUI, scheduled auto-cleaning, Xcode/Homebrew/system cache cleanup. MIT licensed.

test: cover localization resources

aleksandrlugchenko5737663dea6c
diff --git a/PureMacTests/AppLanguagePreferencesTests.swift b/PureMacTests/AppLanguagePreferencesTests.swift
index 1dcb320..3546ec5 100644
--- a/PureMacTests/AppLanguagePreferencesTests.swift
+++ b/PureMacTests/AppLanguagePreferencesTests.swift
@@ -2,6 +2,13 @@ import XCTest
@testable import PureMac
final class AppLanguagePreferencesTests: XCTestCase {
+ func testRussianAndUkrainianLanguagesUseExpectedIdentifiers() {
+ XCTAssertEqual(AppLanguage.russian.rawValue, "ru")
+ XCTAssertEqual(AppLanguage.ukrainian.rawValue, "uk")
+ XCTAssertTrue(AppLanguage.allCases.contains(.russian))
+ XCTAssertTrue(AppLanguage.allCases.contains(.ukrainian))
+ }
+
func testApplyCustomLanguageSetsAppleLanguagesAndPreservesLocale() {
let context = makeDefaults()
let defaults = context.defaults
@@ -13,6 +20,17 @@ final class AppLanguagePreferencesTests: XCTestCase {
XCTAssertEqual(defaults.string(forKey: "AppleLocale"), "pt_BR")
}
+ func testApplyRussianAndUkrainianLanguagesSetsAppleLanguages() {
+ let context = makeDefaults()
+ let defaults = context.defaults
+
+ AppLanguagePreferences.apply(.russian, defaults: defaults)
+ XCTAssertEqual(defaults.array(forKey: "AppleLanguages") as? [String], ["ru"])
+
+ AppLanguagePreferences.apply(.ukrainian, defaults: defaults)
+ XCTAssertEqual(defaults.array(forKey: "AppleLanguages") as? [String], ["uk"])
+ }
+
func testApplySystemLanguageRemovesAppleLanguagesAndPreservesLocale() {
let context = makeDefaults()
let defaults = context.defaults
diff --git a/PureMacTests/LocalizationFilesTests.swift b/PureMacTests/LocalizationFilesTests.swift
index 949abbb..ba38003 100644
--- a/PureMacTests/LocalizationFilesTests.swift
+++ b/PureMacTests/LocalizationFilesTests.swift
@@ -1,6 +1,51 @@
import XCTest
final class LocalizationFilesTests: XCTestCase {
+ func testRussianAndUkrainianLocalizationsExist() throws {
+ let localizationFiles = try localizableStringsFiles()
+
+ XCTAssertNotNil(localizationFiles["ru"], "Expected ru.lproj/Localizable.strings to exist")
+ XCTAssertNotNil(localizationFiles["uk"], "Expected uk.lproj/Localizable.strings to exist")
+ }
+
+ func testBuiltAppBundleContainsRussianAndUkrainianLocalizations() throws {
+ for language in ["ru", "uk"] {
+ XCTAssertTrue(
+ Bundle.main.localizations.contains(language),
+ "Expected the built app bundle to register the \(language) localization"
+ )
+ for resource in ["Localizable", "InfoPlist", "ServicesMenu"] {
+ XCTAssertNotNil(
+ Bundle.main.path(
+ forResource: resource,
+ ofType: "strings",
+ inDirectory: nil,
+ forLocalization: language
+ ),
+ "Expected the built app bundle to contain \(language).lproj/\(resource).strings"
+ )
+ }
+
+ let localizablePath = try XCTUnwrap(
+ Bundle.main.path(
+ forResource: "Localizable",
+ ofType: "strings",
+ inDirectory: nil,
+ forLocalization: language
+ )
+ )
+ let localizationPath = URL(fileURLWithPath: localizablePath)
+ .deletingLastPathComponent()
+ .path
+ let localizationBundle = try XCTUnwrap(Bundle(path: localizationPath))
+ XCTAssertNotEqual(
+ localizationBundle.localizedString(forKey: "Language", value: nil, table: nil),
+ "Language",
+ "Expected the \(language) localization bundle to resolve a translated sentinel value"
+ )
+ }
+ }
+
func testAllLocalizableStringsFilesHaveEnglishKeyParity() throws {
let localizationFiles = try localizableStringsFiles()
let englishURL = try XCTUnwrap(
@@ -25,6 +70,40 @@ final class LocalizationFilesTests: XCTestCase {
}
}
+ func testAllLocalizedValuesPreserveEnglishFormatSpecifiers() throws {
+ let localizationFiles = try localizableStringsFiles()
+ let englishURL = try XCTUnwrap(localizationFiles["en"])
+ let englishStrings = try localizedStrings(in: englishURL)
+
+ for (language, fileURL) in localizationFiles where language != "en" {
+ let localizedStrings = try localizedStrings(in: fileURL)
+
+ for (key, englishValue) in englishStrings {
+ let localizedValue = try XCTUnwrap(localizedStrings[key])
+ XCTAssertEqual(
+ formatSignature(in: localizedValue),
+ formatSignature(in: englishValue),
+ "\(language).lproj has incompatible format specifiers for key: \(key)"
+ )
+ }
+ }
+ }
+
+ func testLocalizableStringsFilesDoNotContainDuplicateKeys() throws {
+ for (language, fileURL) in try localizableStringsFiles() {
+ let keys = try declaredKeys(in: fileURL)
+ let duplicates = Dictionary(grouping: keys, by: { $0 })
+ .filter { $0.value.count > 1 }
+ .keys
+ .sorted()
+
+ XCTAssertTrue(
+ duplicates.isEmpty,
+ "\(language).lproj/Localizable.strings has duplicate keys:\n\(duplicates.joined(separator: "\n"))"
+ )
+ }
+ }
+
private func localizableStringsFiles() throws -> [String: URL] {
let sourceRoot = URL(fileURLWithPath: #filePath)
.deletingLastPathComponent()
@@ -47,14 +126,50 @@ final class LocalizationFilesTests: XCTestCase {
}
private func localizedKeys(in fileURL: URL) throws -> Set<String> {
+ Set(try localizedStrings(in: fileURL).keys)
+ }
+
+ private func localizedStrings(in fileURL: URL) throws -> [String: String] {
let data = try Data(contentsOf: fileURL)
let plist = try PropertyListSerialization.propertyList(from: data, options: [], format: nil)
guard let strings = plist as? [String: String] else {
XCTFail("\(fileURL.path) is not a valid Localizable.strings dictionary")
- return []
+ return [:]
+ }
+
+ return strings
+ }
+
+ private func declaredKeys(in fileURL: URL) throws -> [String] {
+ let contents = try String(contentsOf: fileURL, encoding: .utf8)
+ let regex = try NSRegularExpression(pattern: #"(?m)^"((?:\\.|[^"])*)"\s*="#)
+ let range = NSRange(contents.startIndex..., in: contents)
+
+ return regex.matches(in: contents, range: range).compactMap { match in
+ Range(match.range(at: 1), in: contents).map { String(contents[$0]) }
}
+ }
- return Set(strings.keys)
+ private func formatSignature(in value: String) -> [String] {
+ let pattern = #"%(?:(\d+)\$)?(lld|@|%)"#
+ let regex = try! NSRegularExpression(pattern: pattern)
+ let range = NSRange(value.startIndex..., in: value)
+ var sequentialPosition = 1
+
+ return regex.matches(in: value, range: range).compactMap { match in
+ guard let typeRange = Range(match.range(at: 2), in: value) else { return nil }
+ let type = String(value[typeRange])
+ guard type != "%" else { return "literal-percent" }
+
+ if let explicitRange = Range(match.range(at: 1), in: value),
+ let position = Int(value[explicitRange]) {
+ return "\(position):\(type)"
+ }
+
+ defer { sequentialPosition += 1 }
+ return "\(sequentialPosition):\(type)"
+ }
+ .sorted()
}
}