GLEGram 12.5 — Initial public release

Based on Swiftgram 12.5 (Telegram iOS 12.5).
All GLEGram features ported and organized in GLEGram/ folder.

Features: Ghost Mode, Saved Deleted Messages, Content Protection Bypass,
Font Replacement, Fake Profile, Chat Export, Plugin System, and more.

See CHANGELOG_12.5.md for full details.

third-party/XcodeGen/Tests/XcodeGenCoreTests/ArrayExtensionsTests.swift

@@ -0,0 +1,40 @@
+import XCTest
+@testable import XcodeGenCore
+
+class ArrayExtensionsTests: XCTestCase {
+    
+    func testSearchingForFirstIndex() {
+        let array = SortedArray([1, 2, 3, 4 ,5])
+        XCTAssertEqual(array.firstIndex(where: { $0 > 2 }), 2)
+    }
+    
+    func testIndexCannotBeFound() {
+        let array = SortedArray([1, 2, 3, 4, 5])
+        XCTAssertEqual(array.firstIndex(where: { $0 > 10 }), nil)
+    }
+
+    func testEmptyArray() {
+        let array = SortedArray([Int]())
+        XCTAssertEqual(array.firstIndex(where: { $0 > 0 }), nil)
+    }
+    
+    func testSearchingReturnsFirstIndexWhenMultipleElementsHaveSameValue() {
+        let array = SortedArray([1, 2, 3, 3 ,3])
+        XCTAssertEqual(array.firstIndex(where: { $0 == 3 }), 2)
+    }
+}
+
+
+class SortedArrayTests: XCTestCase {
+    
+    func testSortingOnInitialization() {
+        let array = [1, 5, 4, 2]
+        let sortedArray = SortedArray(array)
+        XCTAssertEqual([1, 2, 4, 5], sortedArray.value)
+    }
+    
+    func testEmpty() {
+        XCTAssertEqual([Int](), SortedArray([Int]()).value)
+    }
+
+}

third-party/XcodeGen/Tests/XcodeGenCoreTests/AtomicTests.swift

@@ -0,0 +1,39 @@
+//
+//  AtomicTests.swift
+//  
+//
+//  Created by Vladislav Lisianskii on 27.03.2022.
+//
+
+import XCTest
+@testable import XcodeGenCore
+
+final class AtomicTests: XCTestCase {
+
+    @Atomic private var atomicDictionary = [String: Int]()
+
+    func testSimultaneousWriteOrder() {
+        let group = DispatchGroup()
+
+        for index in (0..<100) {
+            group.enter()
+            DispatchQueue.global().async {
+                self.$atomicDictionary.with { atomicDictionary in
+                    atomicDictionary["\(index)"] = index
+                }
+                group.leave()
+            }
+        }
+
+        group.notify(queue: .main, execute: {
+            var expectedValue = [String: Int]()
+            for index in (0..<100) {
+                expectedValue["\(index)"] = index
+            }
+            XCTAssertEqual(
+                self.atomicDictionary,
+                expectedValue
+            )
+        })
+    }
+}

third-party/XcodeGen/Tests/XcodeGenCoreTests/GlobTests.swift

@@ -0,0 +1,279 @@
+//
+//  Created by Eric Firestone on 3/22/16.
+//  Copyright © 2016 Square, Inc. All rights reserved.
+//  Released under the Apache v2 License.
+//
+//  Adapted from https://gist.github.com/blakemerryman/76312e1cbf8aec248167
+//  Adapted from https://gist.github.com/efirestone/ce01ae109e08772647eb061b3bb387c3
+
+import XCTest
+@testable import XcodeGenCore
+
+class GlobTests: XCTestCase {
+
+    let tmpFiles = ["foo", "bar", "baz", "dir1/file1.ext", "dir1/dir2/dir3/file2.ext", "dir1/file1.extfoo"]
+    var tmpDir = ""
+
+    override func setUp() {
+        super.setUp()
+
+        tmpDir = newTmpDir()
+
+        let flags = S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH
+        mkdir("\(tmpDir)/dir1/", flags)
+        mkdir("\(tmpDir)/dir1/dir2", flags)
+        mkdir("\(tmpDir)/dir1/dir2/dir3", flags)
+
+        for file in tmpFiles {
+            close(open("\(tmpDir)/\(file)", O_CREAT))
+        }
+    }
+
+    override func tearDown() {
+        for file in tmpFiles {
+            unlink("\(tmpDir)/\(file)")
+        }
+        rmdir("\(tmpDir)/dir1/dir2/dir3")
+        rmdir("\(tmpDir)/dir1/dir2")
+        rmdir("\(tmpDir)/dir1")
+        rmdir(tmpDir)
+
+        super.tearDown()
+    }
+
+    private func newTmpDir() -> String {
+        var tmpDirTmpl = "/tmp/glob-test.XXXXXX".cString(using: .utf8)!
+        return String(validatingUTF8: mkdtemp(&tmpDirTmpl))!
+    }
+
+    func testBraces() {
+        let pattern = "\(tmpDir)/ba{r,y,z}"
+        let glob = Glob(pattern: pattern)
+        var contents = [String]()
+        for file in glob {
+            contents.append(file)
+        }
+        XCTAssertEqual(contents, ["\(tmpDir)/bar", "\(tmpDir)/baz"], "matching with braces failed")
+    }
+
+    func testNothingMatches() {
+        let pattern = "\(tmpDir)/nothing"
+        let glob = Glob(pattern: pattern)
+        var contents = [String]()
+        for file in glob {
+            contents.append(file)
+        }
+        XCTAssertEqual(contents, [], "expected empty list of files")
+    }
+
+    func testDirectAccess() {
+        let pattern = "\(tmpDir)/ba{r,y,z}"
+        let glob = Glob(pattern: pattern)
+        XCTAssertEqual(glob.paths, ["\(tmpDir)/bar", "\(tmpDir)/baz"], "matching with braces failed")
+    }
+
+    func testIterateTwice() {
+        let pattern = "\(tmpDir)/ba{r,y,z}"
+        let glob = Glob(pattern: pattern)
+        var contents1 = [String]()
+        var contents2 = [String]()
+        for file in glob {
+            contents1.append(file)
+        }
+        let filesAfterOnce = glob.paths
+        for file in glob {
+            contents2.append(file)
+        }
+        XCTAssertEqual(contents1, contents2, "results for calling for-in twice are the same")
+        XCTAssertEqual(glob.paths, filesAfterOnce, "calling for-in twice doesn't only memoizes once")
+    }
+
+    func testIndexing() {
+        let pattern = "\(tmpDir)/ba{r,y,z}"
+        let glob = Glob(pattern: pattern)
+        XCTAssertEqual(glob[0], "\(tmpDir)/bar", "indexing")
+    }
+
+    // MARK: - Globstar - Bash v3
+
+    func testGlobstarBashV3NoSlash() {
+        // Should be the equivalent of "ls -d -1 /(tmpdir)/**"
+        let pattern = "\(tmpDir)/**"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorBashV3)
+        XCTAssertEqual(glob.paths, ["\(tmpDir)/bar", "\(tmpDir)/baz", "\(tmpDir)/dir1/", "\(tmpDir)/foo"])
+    }
+
+    func testGlobstarBashV3WithSlash() {
+        // Should be the equivalent of "ls -d -1 /(tmpdir)/**/"
+        let pattern = "\(tmpDir)/**/"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorBashV3)
+        XCTAssertEqual(glob.paths, ["\(tmpDir)/dir1/"])
+    }
+
+    func testGlobstarBashV3WithSlashAndWildcard() {
+        // Should be the equivalent of "ls -d -1 /(tmpdir)/**/*"
+        let pattern = "\(tmpDir)/**/*"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorBashV3)
+        XCTAssertEqual(glob.paths, ["\(tmpDir)/dir1/dir2/", "\(tmpDir)/dir1/file1.ext", "\(tmpDir)/dir1/file1.extfoo"])
+    }
+
+    func testDoubleGlobstarBashV3() {
+        let pattern = "\(tmpDir)/**/dir2/**/*"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorBashV3)
+        XCTAssertEqual(glob.paths, ["\(tmpDir)/dir1/dir2/dir3/file2.ext"])
+    }
+
+    // MARK: - Globstar - Bash v4
+
+    func testGlobstarBashV4NoSlash() {
+        // Should be the equivalent of "ls -d -1 /(tmpdir)/**"
+        let pattern = "\(tmpDir)/**"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorBashV4)
+        XCTAssertEqual(glob.paths, [
+            "\(tmpDir)/",
+            "\(tmpDir)/bar",
+            "\(tmpDir)/baz",
+            "\(tmpDir)/dir1/",
+            "\(tmpDir)/dir1/dir2/",
+            "\(tmpDir)/dir1/dir2/dir3/",
+            "\(tmpDir)/dir1/dir2/dir3/file2.ext",
+            "\(tmpDir)/dir1/file1.ext",
+            "\(tmpDir)/dir1/file1.extfoo",
+            "\(tmpDir)/foo",
+        ])
+    }
+
+    func testGlobstarBashV4WithSlash() {
+        // Should be the equivalent of "ls -d -1 /(tmpdir)/**/"
+        let pattern = "\(tmpDir)/**/"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorBashV4)
+        XCTAssertEqual(glob.paths, [
+            "\(tmpDir)/",
+            "\(tmpDir)/dir1/",
+            "\(tmpDir)/dir1/dir2/",
+            "\(tmpDir)/dir1/dir2/dir3/",
+        ])
+    }
+
+    func testGlobstarBashV4WithSlashAndWildcard() {
+        // Should be the equivalent of "ls -d -1 /(tmpdir)/**/*"
+        let pattern = "\(tmpDir)/**/*"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorBashV4)
+        XCTAssertEqual(glob.paths, [
+            "\(tmpDir)/bar",
+            "\(tmpDir)/baz",
+            "\(tmpDir)/dir1/",
+            "\(tmpDir)/dir1/dir2/",
+            "\(tmpDir)/dir1/dir2/dir3/",
+            "\(tmpDir)/dir1/dir2/dir3/file2.ext",
+            "\(tmpDir)/dir1/file1.ext",
+            "\(tmpDir)/dir1/file1.extfoo",
+            "\(tmpDir)/foo",
+        ])
+    }
+
+    func testDoubleGlobstarBashV4() {
+        let pattern = "\(tmpDir)/**/dir2/**/*"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorBashV4)
+        XCTAssertEqual(glob.paths, [
+            "\(tmpDir)/dir1/dir2/dir3/",
+            "\(tmpDir)/dir1/dir2/dir3/file2.ext",
+        ])
+    }
+
+    func testDoubleGlobstarBashV4WithFileExtension() {
+        // Should be the equivalent of "ls -d -1 /(tmpdir)/**/*.ext"
+        // Should not find "\(tmpDir)/dir1/file1.extfoo" which the file extension prefix is .ext
+        let pattern = "\(tmpDir)/**/*.ext"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorBashV4)
+        XCTAssertEqual(glob.paths, [
+            "\(tmpDir)/dir1/dir2/dir3/file2.ext",
+            "\(tmpDir)/dir1/file1.ext",
+        ])
+    }
+
+    // MARK: - Globstar - Gradle
+
+    func testGlobstarGradleNoSlash() {
+        // Should be the equivalent of
+        // FileTree tree = project.fileTree((Object)'/tmp') {
+        //   include 'glob-test.7m0Lp/**'
+        // }
+        //
+        // Note that the sort order currently matches Bash and not Gradle
+        let pattern = "\(tmpDir)/**"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorGradle)
+        XCTAssertEqual(glob.paths, [
+            "\(tmpDir)/bar",
+            "\(tmpDir)/baz",
+            "\(tmpDir)/dir1/dir2/dir3/file2.ext",
+            "\(tmpDir)/dir1/file1.ext",
+            "\(tmpDir)/dir1/file1.extfoo",
+            "\(tmpDir)/foo",
+        ])
+    }
+
+    func testGlobstarGradleWithSlash() {
+        // Should be the equivalent of
+        // FileTree tree = project.fileTree((Object)'/tmp') {
+        //   include 'glob-test.7m0Lp/**/'
+        // }
+        //
+        // Note that the sort order currently matches Bash and not Gradle
+        let pattern = "\(tmpDir)/**/"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorGradle)
+        XCTAssertEqual(glob.paths, [
+            "\(tmpDir)/bar",
+            "\(tmpDir)/baz",
+            "\(tmpDir)/dir1/dir2/dir3/file2.ext",
+            "\(tmpDir)/dir1/file1.ext",
+            "\(tmpDir)/dir1/file1.extfoo",
+            "\(tmpDir)/foo",
+        ])
+    }
+
+    func testGlobstarGradleWithSlashAndWildcard() {
+        // Should be the equivalent of
+        // FileTree tree = project.fileTree((Object)'/tmp') {
+        //   include 'glob-test.7m0Lp/**/*'
+        // }
+        //
+        // Note that the sort order currently matches Bash and not Gradle
+        let pattern = "\(tmpDir)/**/*"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorGradle)
+        XCTAssertEqual(glob.paths, [
+            "\(tmpDir)/bar",
+            "\(tmpDir)/baz",
+            "\(tmpDir)/dir1/dir2/dir3/file2.ext",
+            "\(tmpDir)/dir1/file1.ext",
+            "\(tmpDir)/dir1/file1.extfoo",
+            "\(tmpDir)/foo",
+        ])
+    }
+
+    func testDoubleGlobstarGradle() {
+        // Should be the equivalent of
+        // FileTree tree = project.fileTree((Object)'/tmp') {
+        //   include 'glob-test.7m0Lp/**/dir2/**/*'
+        // }
+        //
+        // Note that the sort order currently matches Bash and not Gradle
+        let pattern = "\(tmpDir)/**/dir2/**/*"
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorGradle)
+        XCTAssertEqual(glob.paths, [
+            "\(tmpDir)/dir1/dir2/dir3/file2.ext",
+        ])
+    }
+
+    func testBlacklistedDirectories() {
+        let pattern = "\(tmpDir)/**/*"
+
+        let glob = Glob(pattern: pattern, behavior: GlobBehaviorGradle, blacklistedDirectories: ["dir1"])
+
+        XCTAssertEqual(glob.paths, [
+            "\(tmpDir)/bar",
+            "\(tmpDir)/baz",
+            "\(tmpDir)/foo",
+        ])
+    }
+}

third-party/XcodeGen/Tests/XcodeGenCoreTests/PathExtensionsTests.swift

@@ -0,0 +1,68 @@
+import Spectre
+import PathKit
+import XCTest
+import XcodeGenCore
+import TestSupport
+
+class PathExtensionsTests: XCTestCase {
+
+    func testPathRelativeToPath() {
+        func relativePath(to path: String, from base: String) throws -> String {
+            try Path(path).relativePath(from: Path(base)).string
+        }
+
+        // These are based on ruby's tests for Pathname#relative_path_from:
+        // https://github.com/ruby/ruby/blob/7c2bbd1c7d40a30583844d649045824161772e36/test/pathname/test_pathname.rb#L297
+        describe {
+            $0.it("resolves single-level paths") {
+                try expect(relativePath(to: "a", from: "b")) == "../a"
+                try expect(relativePath(to: "a", from: "b/")) == "../a"
+                try expect(relativePath(to: "a/", from: "b")) == "../a"
+                try expect(relativePath(to: "a/", from: "b/")) == "../a"
+                try expect(relativePath(to: "/a", from: "/b")) == "../a"
+                try expect(relativePath(to: "/a", from: "/b/")) == "../a"
+                try expect(relativePath(to: "/a/", from: "/b")) == "../a"
+                try expect(relativePath(to: "/a/", from: "/b/")) == "../a"
+            }
+
+            $0.it("resolves paths with a common parent") {
+                try expect(relativePath(to: "a/b", from: "a/c")) == "../b"
+                try expect(relativePath(to: "../a", from: "../b")) == "../a"
+            }
+
+            $0.it("resolves dot paths") {
+                try expect(relativePath(to: "a", from: ".")) == "a"
+                try expect(relativePath(to: ".", from: "a")) == ".."
+                try expect(relativePath(to: ".", from: ".")) == "."
+                try expect(relativePath(to: "..", from: "..")) == "."
+                try expect(relativePath(to: "..", from: ".")) == ".."
+            }
+
+            $0.it("resolves multi-level paths") {
+                try expect(relativePath(to: "/a/b/c/d", from: "/a/b")) == "c/d"
+                try expect(relativePath(to: "/a/b", from: "/a/b/c/d")) == "../.."
+                try expect(relativePath(to: "/e", from: "/a/b/c/d")) == "../../../../e"
+                try expect(relativePath(to: "a/b/c", from: "a/d")) == "../b/c"
+                try expect(relativePath(to: "/../a", from: "/b")) == "../a"
+                try expect(relativePath(to: "../a", from: "b")) == "../../a"
+                try expect(relativePath(to: "/a/../../b", from: "/b")) == "."
+                try expect(relativePath(to: "a/..", from: "a")) == ".."
+                try expect(relativePath(to: "a/../b", from: "b")) == "."
+                try expect(relativePath(to: "/a/c", from: "/a/b/c")) == "../../c"
+            }
+
+            $0.it("backtracks on a non-normalized base path") {
+                try expect(relativePath(to: "a", from: "b/..")) == "a"
+                try expect(relativePath(to: "b/c", from: "b/..")) == "b/c"
+            }
+
+            $0.it("throws when given unresolvable paths") {
+                try expect(relativePath(to: "/", from: ".")).toThrow()
+                try expect(relativePath(to: ".", from: "/")).toThrow()
+                try expect(relativePath(to: "a", from: "..")).toThrow()
+                try expect(relativePath(to: ".", from: "..")).toThrow()
+                try expect(relativePath(to: "a", from: "b/../..")).toThrow()
+            }
+        }
+    }
+}