| // Copyright 2018 The Tulsi Authors. All rights reserved. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| import XCTest | |
| @testable import TulsiGenerator | |
| class BuildSettingsTests: XCTestCase { | |
| func testBazelFlagsEmpty() { | |
| XCTAssert(BazelFlags().isEmpty) | |
| XCTAssertEqual(BazelFlags().toPython(""), "BazelFlags()") | |
| } | |
| func testBazelFlagsOperators() { | |
| let a = BazelFlags(startupStr: "a b", buildStr: "x y") | |
| let b = BazelFlags(startupStr: "c d", buildStr: "z 1") | |
| let aExplicit = BazelFlags(startup: ["a", "b"], build: ["x", "y"]) | |
| let bExplicit = BazelFlags(startup: ["c", "d"], build: ["z", "1"]) | |
| XCTAssertEqual(a, aExplicit) | |
| XCTAssertEqual(b, bExplicit) | |
| let c = a + b | |
| XCTAssertEqual(c.startup, ["a", "b", "c", "d"]) | |
| XCTAssertEqual(c.build, ["x", "y", "z", "1"]) | |
| XCTAssertNotEqual(c, b + a) | |
| } | |
| func testBazelFlagsPythonable() { | |
| let startup = ["--startup-flag"] | |
| let build = ["--build-flag"] | |
| XCTAssertEqual(BazelFlags(startup: startup, build: build).toPython(""), """ | |
| BazelFlags( | |
| startup = [ | |
| '--startup-flag', | |
| ], | |
| build = [ | |
| '--build-flag', | |
| ], | |
| ) | |
| """) | |
| } | |
| func testBazelFlagsSetEmpty() { | |
| XCTAssert(BazelFlagsSet().isEmpty) | |
| XCTAssertEqual(BazelFlagsSet().toPython(""), "BazelFlagsSet()") | |
| } | |
| func testBazelFlagsSetInitializers() { | |
| let basicFlagsSet = BazelFlagsSet(startupFlags: ["a"], buildFlags: ["b"]) | |
| let basicFlags = BazelFlags(startup: ["a"], build: ["b"]) | |
| XCTAssertEqual(basicFlagsSet.release, basicFlags) | |
| XCTAssertEqual(basicFlagsSet.debug, basicFlags) | |
| XCTAssertEqual(basicFlagsSet.getFlags(forDebug: true), basicFlagsSet.debug) | |
| XCTAssertEqual(basicFlagsSet.getFlags(forDebug: false), basicFlagsSet.release) | |
| let complexFlagSet = BazelFlagsSet(debug: BazelFlags(startup: ["a"], build: ["b"]), | |
| release: BazelFlags(startup: ["x"], build: ["y"]), | |
| common: BazelFlags(startup: ["1"], build: ["2"])) | |
| XCTAssertEqual(complexFlagSet.debug, BazelFlags(startup: ["a", "1"], build: ["b", "2"])) | |
| XCTAssertEqual(complexFlagSet.release, BazelFlags(startup: ["x", "1"], build: ["y", "2"])) | |
| } | |
| func testBazelFlagsSetPythonable() { | |
| let basicFlagsSet = BazelFlagsSet(startupFlags: ["a"], buildFlags: ["b"]) | |
| XCTAssertEqual(basicFlagsSet.toPython(""), """ | |
| BazelFlagsSet( | |
| flags = BazelFlags( | |
| startup = [ | |
| 'a', | |
| ], | |
| build = [ | |
| 'b', | |
| ], | |
| ), | |
| ) | |
| """) | |
| let complexFlagSet = BazelFlagsSet(debug: BazelFlags(startup: ["a"], build: ["b"]), | |
| release: BazelFlags(startup: ["x"], build: ["y"]), | |
| common: BazelFlags(startup: ["1"], build: ["2"])) | |
| XCTAssertEqual(complexFlagSet.toPython(""), """ | |
| BazelFlagsSet( | |
| debug = BazelFlags( | |
| startup = [ | |
| 'a', | |
| '1', | |
| ], | |
| build = [ | |
| 'b', | |
| '2', | |
| ], | |
| ), | |
| release = BazelFlags( | |
| startup = [ | |
| 'x', | |
| '1', | |
| ], | |
| build = [ | |
| 'y', | |
| '2', | |
| ], | |
| ), | |
| ) | |
| """) | |
| } | |
| func testBazelBuildSettingsPythonable() { | |
| let bazel = "/path/to/bazel" | |
| let bazelExecRoot = "__MOCK_EXEC_ROOT__" | |
| let defaultIdentifier = "fake_config" | |
| let platformConfigurationFlags = [ | |
| "fake_config": ["a", "b"], | |
| "another_one": ["--x", "-c"], | |
| ] | |
| let swiftTargets: Set<String> = [ | |
| "//dir/swiftTarget:swiftTarget", | |
| "//dir/nested/depOnswift:depOnswift" | |
| ] | |
| let cacheAffecting = BazelFlagsSet(startupFlags: ["--nocacheStartup"], | |
| buildFlags: ["--nocacheBuild"]) | |
| let cacheSafe = BazelFlagsSet(startupFlags: ["--cacheSafeStartup"], | |
| buildFlags: ["--cacheSafeBuild"]) | |
| let swift = BazelFlagsSet(buildFlags: ["--swift-only"]) | |
| let nonSwift = BazelFlagsSet(startupFlags: ["--non-swift-only"]) | |
| let projDefaults = BazelFlagsSet() | |
| let projTargetFlags = [ | |
| "//dir/some/customized:target": BazelFlagsSet(buildFlags: ["a", "b"]), | |
| ] | |
| let swiftFeatures = [BazelSettingFeature.DebugPathNormalization.stringValue] | |
| let nonSwiftFeatures = [BazelSettingFeature.DebugPathNormalization.stringValue] | |
| let settings = BazelBuildSettings(bazel: bazel, | |
| bazelExecRoot: bazelExecRoot, | |
| defaultPlatformConfigIdentifier: defaultIdentifier, | |
| platformConfigurationFlags: platformConfigurationFlags, | |
| swiftTargets: swiftTargets, | |
| tulsiCacheAffectingFlagsSet: cacheAffecting, | |
| tulsiCacheSafeFlagSet: cacheSafe, | |
| tulsiSwiftFlagSet: swift, | |
| tulsiNonSwiftFlagSet: nonSwift, | |
| swiftFeatures: swiftFeatures, | |
| nonSwiftFeatures: nonSwiftFeatures, | |
| projDefaultFlagSet: projDefaults, | |
| projTargetFlagSets: projTargetFlags) | |
| XCTAssertEqual(settings.toPython(""), """ | |
| BazelBuildSettings( | |
| '\(bazel)', | |
| '\(bazelExecRoot)', | |
| '\(defaultIdentifier)', | |
| \(platformConfigurationFlags.toPython(" ")), | |
| \(swiftTargets.toPython(" ")), | |
| \(cacheAffecting.toPython(" ")), | |
| \(cacheSafe.toPython(" ")), | |
| \(swift.toPython(" ")), | |
| \(nonSwift.toPython(" ")), | |
| \(swiftFeatures.toPython(" ")), | |
| \(nonSwiftFeatures.toPython(" ")), | |
| \(projDefaults.toPython(" ")), | |
| \(projTargetFlags.toPython(" ")), | |
| ) | |
| """) | |
| } | |
| } |