blob: 94e6af1c249eda079a5f64bcffef75e94e5b04a4 [file] [log] [blame]
// 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(" ")),
)
"""
)
}
}