612 lines
25 KiB
Swift
612 lines
25 KiB
Swift
import MapLibre
|
|
import XCTest
|
|
|
|
/**
|
|
Test cases that ensure the inline examples in the project documentation
|
|
compile.
|
|
|
|
To add an example:
|
|
1. Add a test case named in the form testMLNClass or testMLNClass$method.
|
|
2. Wrap the code you'd like to appear in the documentation within the
|
|
following comment blocks:
|
|
```
|
|
//#-example-code
|
|
...
|
|
//#-end-example-code
|
|
```
|
|
3. Insert an empty Swift code block inside the header file where you'd like the
|
|
example code to be inserted.
|
|
4. Run `make darwin-update-examples` to extract example code from the test
|
|
method below and insert it into the header.
|
|
*/
|
|
class MLNDocumentationExampleTests: XCTestCase, MLNMapViewDelegate {
|
|
var mapView: MLNMapView!
|
|
var styleLoadingExpectation: XCTestExpectation!
|
|
static let styleURL = Bundle(for: MLNDocumentationExampleTests.self).url(forResource: "one-liner", withExtension: "json")!
|
|
|
|
// Mock MLNOfflineStorage singleton so that it doesn't start long-running tasks that could interfere with other tests.
|
|
fileprivate class MLNOfflineStorageMock {
|
|
static let shared = MLNOfflineStorageMock()
|
|
func addPack(for: MLNOfflineRegion, withContext: Data, completionHandler: MLNOfflinePackAdditionCompletionHandler? = nil) {
|
|
XCTAssert(MLNOfflineStorage.shared.responds(to: #selector(MLNOfflineStorage.shared.addPack(for:withContext:completionHandler:))))
|
|
if let completionHandler {
|
|
completionHandler(nil, NSError(domain: "MLNDocumentationExampleError", code: 0, userInfo: [NSLocalizedDescriptionKey: "\(#function) is mocked and not functional."]))
|
|
}
|
|
}
|
|
}
|
|
|
|
override func setUp() {
|
|
super.setUp()
|
|
mapView = MLNMapView(frame: CGRect(x: 0, y: 0, width: 256, height: 256), styleURL: MLNDocumentationExampleTests.styleURL)
|
|
mapView.delegate = self
|
|
styleLoadingExpectation = expectation(description: "Map view should finish loading style")
|
|
waitForExpectations(timeout: 10, handler: nil)
|
|
}
|
|
|
|
override func tearDown() {
|
|
mapView = nil
|
|
styleLoadingExpectation = nil
|
|
super.tearDown()
|
|
}
|
|
|
|
func mapView(_: MLNMapView, didFinishLoading _: MLNStyle) {
|
|
styleLoadingExpectation.fulfill()
|
|
}
|
|
|
|
func testMLNLight() {
|
|
// #-example-code
|
|
let light = MLNLight()
|
|
let position = MLNSphericalPosition(radial: 5, azimuthal: 180, polar: 80)
|
|
light.position = NSExpression(forConstantValue: NSValue(mlnSphericalPosition: position))
|
|
light.anchor = NSExpression(forConstantValue: "map")
|
|
mapView.style?.light = light
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.light)
|
|
}
|
|
|
|
func testMLNTilePyramidOfflineRegion() {
|
|
class MLNStyle {
|
|
static var lightStyleURL: URL {
|
|
MLNDocumentationExampleTests.styleURL
|
|
}
|
|
}
|
|
|
|
typealias MLNOfflineStorage = MLNOfflineStorageMock
|
|
|
|
// #-example-code
|
|
let northeast = CLLocationCoordinate2D(latitude: 40.989329, longitude: -102.062592)
|
|
let southwest = CLLocationCoordinate2D(latitude: 36.986207, longitude: -109.049896)
|
|
let bbox = MLNCoordinateBounds(sw: southwest, ne: northeast)
|
|
|
|
let region = MLNTilePyramidOfflineRegion(styleURL: MLNStyle.lightStyleURL, bounds: bbox, fromZoomLevel: 11, toZoomLevel: 14)
|
|
let context = "Tile Pyramid Region".data(using: .utf8)
|
|
MLNOfflineStorage.shared.addPack(for: region, withContext: context!)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(region)
|
|
}
|
|
|
|
func testMLNShapeOfflineRegion() {
|
|
class MLNStyle {
|
|
static var lightStyleURL: URL {
|
|
MLNDocumentationExampleTests.styleURL
|
|
}
|
|
}
|
|
|
|
typealias MLNOfflineStorage = MLNOfflineStorageMock
|
|
|
|
// #-example-code
|
|
var coordinates = [
|
|
CLLocationCoordinate2D(latitude: 45.522585, longitude: -122.685699),
|
|
CLLocationCoordinate2D(latitude: 45.534611, longitude: -122.708873),
|
|
CLLocationCoordinate2D(latitude: 45.530883, longitude: -122.678833),
|
|
]
|
|
|
|
let triangle = MLNPolygon(coordinates: &coordinates, count: UInt(coordinates.count))
|
|
let region = MLNShapeOfflineRegion(styleURL: MLNStyle.lightStyleURL, shape: triangle, fromZoomLevel: 11, toZoomLevel: 14)
|
|
let context = "Triangle Region".data(using: .utf8)
|
|
MLNOfflineStorage.shared.addPack(for: region, withContext: context!)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(region)
|
|
}
|
|
|
|
func testMLNOfflinePack() {
|
|
typealias MLNOfflineStorage = MLNOfflineStorageMock
|
|
|
|
let northeast = CLLocationCoordinate2D(latitude: 40.989329, longitude: -102.062592)
|
|
let southwest = CLLocationCoordinate2D(latitude: 36.986207, longitude: -109.049896)
|
|
let bbox = MLNCoordinateBounds(sw: southwest, ne: northeast)
|
|
let region = MLNTilePyramidOfflineRegion(styleURL: MLNDocumentationExampleTests.styleURL, bounds: bbox, fromZoomLevel: 11, toZoomLevel: 14)
|
|
let context = "Tile Pyramid Region".data(using: .utf8)!
|
|
|
|
// #-example-code
|
|
MLNOfflineStorage.shared.addPack(for: region, withContext: context) { pack, error in
|
|
guard let pack else {
|
|
// If adding the pack fails, log an error to console.
|
|
print("Error:", error?.localizedDescription ?? "unknown error adding pack at \(#file)(\(#line)) in \(#function)")
|
|
return
|
|
}
|
|
|
|
// Start an MLNOfflinePack download
|
|
pack.resume()
|
|
}
|
|
// #-end-example-code
|
|
}
|
|
|
|
func testMLNShape$shapeWithData_encoding_error_() {
|
|
let mainBundle = Bundle(for: MLNDocumentationExampleTests.self)
|
|
|
|
// #-example-code
|
|
let url = mainBundle.url(forResource: "amsterdam", withExtension: "geojson")!
|
|
let data = try! Data(contentsOf: url)
|
|
let feature = try! MLNShape(data: data, encoding: String.Encoding.utf8.rawValue) as! MLNShapeCollectionFeature
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(feature.shapes.first as? MLNPolygonFeature)
|
|
}
|
|
|
|
func testMLNShapeSource() {
|
|
// #-example-code
|
|
var coordinates: [CLLocationCoordinate2D] = [
|
|
CLLocationCoordinate2D(latitude: 37.77, longitude: -122.42),
|
|
CLLocationCoordinate2D(latitude: 38.91, longitude: -77.04),
|
|
]
|
|
let polyline = MLNPolylineFeature(coordinates: &coordinates, count: UInt(coordinates.count))
|
|
let source = MLNShapeSource(identifier: "lines", features: [polyline], options: nil)
|
|
mapView.style?.addSource(source)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.source(withIdentifier: "lines"))
|
|
}
|
|
|
|
func testMLNRasterTileSource() {
|
|
// #-example-code
|
|
let source = MLNRasterTileSource(identifier: "clouds", tileURLTemplates: ["https://example.com/raster-tiles/{z}/{x}/{y}.png"], options: [
|
|
.minimumZoomLevel: 9,
|
|
.maximumZoomLevel: 16,
|
|
.tileSize: 512,
|
|
.attributionInfos: [
|
|
MLNAttributionInfo(title: NSAttributedString(string: "© Mapbox"), url: URL(string: "https://mapbox.com")),
|
|
],
|
|
])
|
|
mapView.style?.addSource(source)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.source(withIdentifier: "clouds"))
|
|
}
|
|
|
|
func testMLNRasterDEMSource() {
|
|
// We want to use mapbox.terrain-rgb in the example, but using a mapbox:
|
|
// URL requires setting an access token. So this identically named
|
|
// subclass of MLNRasterDEMSource swaps in a nonexistent URL.
|
|
class MLNRasterDEMSource: MapLibre.MLNRasterDEMSource {
|
|
override init(identifier: String, configurationURL: URL, tileSize: CGFloat = 256) {
|
|
let bogusURL = URL(string: "https://example.com/raster-rgb.json")!
|
|
super.init(identifier: identifier, configurationURL: bogusURL, tileSize: tileSize)
|
|
}
|
|
}
|
|
|
|
// #-example-code
|
|
let terrainRGBURL = URL(string: "maptiler://sources/terrain-rgb")!
|
|
let source = MLNRasterDEMSource(identifier: "hills", configurationURL: terrainRGBURL)
|
|
mapView.style?.addSource(source)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.source(withIdentifier: "hills"))
|
|
}
|
|
|
|
func testMLNVectorTileSource() {
|
|
// #-example-code
|
|
let source = MLNVectorTileSource(identifier: "pois", tileURLTemplates: ["https://example.com/vector-tiles/{z}/{x}/{y}.mvt"], options: [
|
|
.minimumZoomLevel: 9,
|
|
.maximumZoomLevel: 16,
|
|
.attributionInfos: [
|
|
MLNAttributionInfo(title: NSAttributedString(string: "© Mapbox"), url: URL(string: "https://mapbox.com")),
|
|
],
|
|
])
|
|
mapView.style?.addSource(source)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.source(withIdentifier: "pois"))
|
|
}
|
|
|
|
func testMLNPolyline() {
|
|
// #-example-code
|
|
let coordinates = [
|
|
CLLocationCoordinate2D(latitude: 35.68476, longitude: -220.24257),
|
|
CLLocationCoordinate2D(latitude: 37.78428, longitude: -122.41310),
|
|
]
|
|
let polyline = MLNPolyline(coordinates: coordinates, count: UInt(coordinates.count))
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(polyline)
|
|
}
|
|
|
|
func testMLNImageSource() {
|
|
// #-example-code
|
|
let coordinates = MLNCoordinateQuad(
|
|
topLeft: CLLocationCoordinate2D(latitude: 46.437, longitude: -80.425),
|
|
bottomLeft: CLLocationCoordinate2D(latitude: 37.936, longitude: -80.425),
|
|
bottomRight: CLLocationCoordinate2D(latitude: 37.936, longitude: -71.516),
|
|
topRight: CLLocationCoordinate2D(latitude: 46.437, longitude: -71.516)
|
|
)
|
|
let source = MLNImageSource(identifier: "radar", coordinateQuad: coordinates, url: URL(string: "https://maplibre.org/maplibre-gl-js-docs/assets/radar.gif")!)
|
|
mapView.style?.addSource(source)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.source(withIdentifier: "radar"))
|
|
}
|
|
|
|
func testMLNCircleStyleLayer() {
|
|
let population = MLNVectorTileSource(identifier: "population", configurationURL: URL(string: "https://example.com/style.json")!)
|
|
mapView.style?.addSource(population)
|
|
|
|
// #-example-code
|
|
let layer = MLNCircleStyleLayer(identifier: "circles", source: population)
|
|
layer.sourceLayerIdentifier = "population"
|
|
#if os(macOS)
|
|
layer.circleColor = NSExpression(forConstantValue: NSColor.green)
|
|
#else
|
|
layer.circleColor = NSExpression(forConstantValue: UIColor.green)
|
|
#endif
|
|
|
|
let stops = NSExpression(forConstantValue: [12: 2,
|
|
22: 180])
|
|
layer.circleRadius = NSExpression(forMLNInterpolating: .zoomLevelVariable,
|
|
curveType: .exponential,
|
|
parameters: NSExpression(forConstantValue: 1.75),
|
|
stops: stops)
|
|
|
|
layer.circleOpacity = NSExpression(forConstantValue: 0.7)
|
|
layer.predicate = NSPredicate(format: "%K == %@", "marital-status", "married")
|
|
mapView.style?.addLayer(layer)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.layer(withIdentifier: "circles"))
|
|
}
|
|
|
|
func testMLNLineStyleLayer() {
|
|
let trails = MLNVectorTileSource(identifier: "trails", configurationURL: URL(string: "https://example.com/style.json")!)
|
|
mapView.style?.addSource(trails)
|
|
|
|
// #-example-code
|
|
let layer = MLNLineStyleLayer(identifier: "trails-path", source: trails)
|
|
layer.sourceLayerIdentifier = "trails"
|
|
|
|
let stops = NSExpression(forConstantValue: [14: 2,
|
|
18: 20])
|
|
layer.lineWidth = NSExpression(forMLNInterpolating: .zoomLevelVariable,
|
|
curveType: .exponential,
|
|
parameters: NSExpression(forConstantValue: 1.5),
|
|
stops: stops)
|
|
|
|
#if os(macOS)
|
|
layer.lineColor = NSExpression(forConstantValue: NSColor.brown)
|
|
#else
|
|
layer.lineColor = NSExpression(forConstantValue: UIColor.brown)
|
|
#endif
|
|
layer.lineCap = NSExpression(forConstantValue: "round")
|
|
layer.predicate = NSPredicate(format: "%K == %@", "trail-type", "mountain-biking")
|
|
mapView.style?.addLayer(layer)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.layer(withIdentifier: "trails-path"))
|
|
}
|
|
|
|
func testMLNFillStyleLayer() {
|
|
let parks = MLNVectorTileSource(identifier: "parks", configurationURL: URL(string: "https://example.com/style.json")!)
|
|
mapView.style?.addSource(parks)
|
|
|
|
// #-example-code
|
|
let layer = MLNFillStyleLayer(identifier: "parks", source: parks)
|
|
layer.sourceLayerIdentifier = "parks"
|
|
#if os(macOS)
|
|
layer.fillColor = NSExpression(forConstantValue: NSColor.green)
|
|
#else
|
|
layer.fillColor = NSExpression(forConstantValue: UIColor.green)
|
|
#endif
|
|
layer.predicate = NSPredicate(format: "type == %@", "national-park")
|
|
mapView.style?.addLayer(layer)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.layer(withIdentifier: "parks"))
|
|
}
|
|
|
|
func testMLNFillExtrusionStyleLayer() {
|
|
let buildings = MLNVectorTileSource(identifier: "buildings", configurationURL: URL(string: "https://example.com/style.json")!)
|
|
mapView.style?.addSource(buildings)
|
|
|
|
// #-example-code
|
|
let layer = MLNFillExtrusionStyleLayer(identifier: "buildings", source: buildings)
|
|
layer.sourceLayerIdentifier = "building"
|
|
layer.fillExtrusionHeight = NSExpression(forKeyPath: "height")
|
|
layer.fillExtrusionBase = NSExpression(forKeyPath: "min_height")
|
|
layer.predicate = NSPredicate(format: "extrude == 'true'")
|
|
mapView.style?.addLayer(layer)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.layer(withIdentifier: "buildings"))
|
|
}
|
|
|
|
func testMLNHeatmapStyleLayer() {
|
|
let earthquakes = MLNShapeSource(identifier: "earthquakes", url: URL(string: "https://example.com/earthquakes.json")!, options: [:])
|
|
mapView.style?.addSource(earthquakes)
|
|
|
|
// #-example-code
|
|
let layer = MLNHeatmapStyleLayer(identifier: "earthquake-heat", source: earthquakes)
|
|
|
|
layer.heatmapWeight = NSExpression(forMLNInterpolating: .zoomLevelVariable,
|
|
curveType: .linear,
|
|
parameters: nil,
|
|
stops: NSExpression(forConstantValue: [0: 0,
|
|
6: 1]))
|
|
|
|
layer.heatmapIntensity = NSExpression(forMLNInterpolating: .zoomLevelVariable,
|
|
curveType: .linear,
|
|
parameters: nil,
|
|
stops: NSExpression(forConstantValue: [0: 1,
|
|
9: 3]))
|
|
|
|
mapView.style?.addLayer(layer)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.layer(withIdentifier: "earthquake-heat"))
|
|
}
|
|
|
|
func testMLNSymbolStyleLayer() {
|
|
let pois = MLNVectorTileSource(identifier: "pois", configurationURL: URL(string: "https://example.com/style.json")!)
|
|
mapView.style?.addSource(pois)
|
|
|
|
// #-example-code
|
|
let layer = MLNSymbolStyleLayer(identifier: "coffeeshops", source: pois)
|
|
layer.sourceLayerIdentifier = "pois"
|
|
layer.iconImageName = NSExpression(forConstantValue: "coffee")
|
|
layer.iconScale = NSExpression(forConstantValue: 0.5)
|
|
layer.text = NSExpression(forKeyPath: "name")
|
|
#if os(macOS)
|
|
var vector = CGVector(dx: 10, dy: 0)
|
|
layer.textTranslation = NSExpression(forConstantValue: NSValue(bytes: &vector, objCType: "{CGVector=dd}"))
|
|
#else
|
|
layer.textTranslation = NSExpression(forConstantValue: NSValue(cgVector: CGVector(dx: 10, dy: 0)))
|
|
#endif
|
|
layer.textJustification = NSExpression(forConstantValue: "left")
|
|
layer.textAnchor = NSExpression(forConstantValue: "left")
|
|
layer.predicate = NSPredicate(format: "%K == %@", "venue-type", "coffee")
|
|
mapView.style?.addLayer(layer)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.layer(withIdentifier: "coffeeshops"))
|
|
}
|
|
|
|
func testMLNRasterStyleLayer() {
|
|
let source = MLNRasterTileSource(identifier: "clouds", tileURLTemplates: ["https://example.com/raster-tiles/{z}/{x}/{y}.png"], options: [
|
|
.minimumZoomLevel: 9,
|
|
.maximumZoomLevel: 16,
|
|
.tileSize: 512,
|
|
.attributionInfos: [
|
|
MLNAttributionInfo(title: NSAttributedString(string: "© Mapbox"), url: URL(string: "https://mapbox.com")),
|
|
],
|
|
])
|
|
mapView.style?.addSource(source)
|
|
|
|
// #-example-code
|
|
let layer = MLNRasterStyleLayer(identifier: "clouds", source: source)
|
|
layer.rasterOpacity = NSExpression(forConstantValue: 0.5)
|
|
mapView.style?.addLayer(layer)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.layer(withIdentifier: "clouds"))
|
|
}
|
|
|
|
func testMLNHillshadeStyleLayer() {
|
|
let source = MLNRasterDEMSource(identifier: "dem", tileURLTemplates: ["https://example.com/raster-rgb/{z}/{x}/{y}.png"], options: [
|
|
.minimumZoomLevel: 9,
|
|
.maximumZoomLevel: 16,
|
|
.tileSize: 256,
|
|
.attributionInfos: [
|
|
MLNAttributionInfo(title: NSAttributedString(string: "© Mapbox"), url: URL(string: "https://mapbox.com")),
|
|
],
|
|
])
|
|
mapView.style?.addSource(source)
|
|
|
|
let canals = MLNVectorTileSource(identifier: "canals", configurationURL: URL(string: "https://example.com/style.json")!)
|
|
mapView.style?.addSource(canals)
|
|
let canalShadowLayer = MLNLineStyleLayer(identifier: "waterway-river-canal-shadow", source: canals)
|
|
mapView.style?.addLayer(canalShadowLayer)
|
|
|
|
// #-example-code
|
|
let layer = MLNHillshadeStyleLayer(identifier: "hills", source: source)
|
|
layer.hillshadeExaggeration = NSExpression(forConstantValue: 0.6)
|
|
if let canalShadowLayer = mapView.style?.layer(withIdentifier: "waterway-river-canal-shadow") {
|
|
mapView.style?.insertLayer(layer, below: canalShadowLayer)
|
|
}
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.layer(withIdentifier: "hills"))
|
|
}
|
|
|
|
func testMLNVectorStyleLayer$predicate() {
|
|
let terrain = MLNVectorTileSource(identifier: "terrain", configurationURL: URL(string: "https://example.com/style.json")!)
|
|
mapView.style?.addSource(terrain)
|
|
|
|
// #-example-code
|
|
let layer = MLNLineStyleLayer(identifier: "contour", source: terrain)
|
|
layer.sourceLayerIdentifier = "contours"
|
|
layer.predicate = NSPredicate(format: "(index == 5 || index == 10) && CAST(ele, 'NSNumber') >= 1500.0")
|
|
mapView.style?.addLayer(layer)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(mapView.style?.layer(withIdentifier: "contour"))
|
|
}
|
|
|
|
func testMLNMapView() {
|
|
// #-example-code
|
|
#if os(macOS)
|
|
class MapClickGestureRecognizer: NSClickGestureRecognizer {
|
|
override func shouldRequireFailure(of otherGestureRecognizer: NSGestureRecognizer) -> Bool {
|
|
otherGestureRecognizer is NSClickGestureRecognizer
|
|
}
|
|
}
|
|
#else
|
|
let mapTapGestureRecognizer = UITapGestureRecognizer(target: self, action: #selector(myCustomFunction))
|
|
for recognizer in mapView.gestureRecognizers! where recognizer is UITapGestureRecognizer {
|
|
mapTapGestureRecognizer.require(toFail: recognizer)
|
|
}
|
|
mapView.addGestureRecognizer(mapTapGestureRecognizer)
|
|
#endif
|
|
// #-end-example-code
|
|
}
|
|
|
|
func testMLNMapSnapshotter() throws {
|
|
throw XCTSkip("Snapshotter not implemented yet for Metal. See https://github.com/maplibre/maplibre-native/issues/1862")
|
|
|
|
let expectation = expectation(description: "MLNMapSnapshotter should produce a snapshot")
|
|
#if os(macOS)
|
|
var image: NSImage? {
|
|
didSet {
|
|
expectation.fulfill()
|
|
}
|
|
}
|
|
#else
|
|
var image: UIImage? {
|
|
didSet {
|
|
expectation.fulfill()
|
|
}
|
|
}
|
|
#endif
|
|
|
|
class MLNStyle {
|
|
static var satelliteStreetsStyleURL: URL {
|
|
MLNDocumentationExampleTests.styleURL
|
|
}
|
|
}
|
|
|
|
// #-example-code
|
|
let camera = MLNMapCamera(lookingAtCenter: CLLocationCoordinate2D(latitude: 37.7184, longitude: -122.4365), altitude: 100, pitch: 20, heading: 0)
|
|
|
|
let options = MLNMapSnapshotOptions(styleURL: MLNStyle.satelliteStreetsStyleURL, camera: camera, size: CGSize(width: 320, height: 480))
|
|
options.zoomLevel = 10
|
|
|
|
let snapshotter = MLNMapSnapshotter(options: options)
|
|
snapshotter.start { snapshot, error in
|
|
if let error {
|
|
fatalError(error.localizedDescription)
|
|
}
|
|
|
|
image = snapshot?.image
|
|
}
|
|
// #-end-example-code
|
|
|
|
wait(for: [expectation], timeout: 5)
|
|
_ = image
|
|
}
|
|
|
|
func testMLNCluster() {
|
|
enum ExampleError: Error {
|
|
case unexpectedFeatureType
|
|
case featureIsNotACluster
|
|
}
|
|
|
|
let geoJSON: [String: Any] = [
|
|
"type": "Feature",
|
|
"geometry": [
|
|
"coordinates": [
|
|
-77.00896639534831,
|
|
38.87031006108791,
|
|
0.0,
|
|
],
|
|
"type": "Point",
|
|
] as [String: Any],
|
|
"properties": [
|
|
"cluster": true,
|
|
"cluster_id": 123,
|
|
"point_count": 4567,
|
|
] as [String: Any],
|
|
]
|
|
|
|
let clusterShapeData = try! JSONSerialization.data(withJSONObject: geoJSON, options: [])
|
|
|
|
do {
|
|
// #-example-code
|
|
let shape = try! MLNShape(data: clusterShapeData, encoding: String.Encoding.utf8.rawValue)
|
|
|
|
guard let pointFeature = shape as? MLNPointFeature else {
|
|
throw ExampleError.unexpectedFeatureType
|
|
}
|
|
|
|
// Check for cluster conformance
|
|
guard let cluster = pointFeature as? MLNCluster else {
|
|
throw ExampleError.featureIsNotACluster
|
|
}
|
|
|
|
// Currently the only supported class that conforms to ``MLNCluster`` is
|
|
// ``MLNPointFeatureCluster``
|
|
guard cluster is MLNPointFeatureCluster else {
|
|
throw ExampleError.unexpectedFeatureType
|
|
}
|
|
|
|
// #-end-example-code
|
|
|
|
XCTAssert(cluster.clusterIdentifier == 123)
|
|
XCTAssert(cluster.clusterPointCount == 4567)
|
|
} catch {
|
|
XCTFail("Example failed with thrown error: \(error)")
|
|
}
|
|
}
|
|
|
|
func testMLNAttributedExpression() {
|
|
// #-example-code
|
|
#if os(macOS)
|
|
let redColor = NSColor.red
|
|
#else
|
|
let redColor = UIColor.red
|
|
#endif
|
|
let expression = NSExpression(forConstantValue: "Foo")
|
|
let attributes: [MLNAttributedExpressionKey: NSExpression] = [.fontNamesAttribute: NSExpression(forConstantValue: ["DIN Offc Pro Italic",
|
|
"Arial Unicode MS Regular"]),
|
|
.fontScaleAttribute: NSExpression(forConstantValue: 1.2),
|
|
.fontColorAttribute: NSExpression(forConstantValue: redColor)]
|
|
let attributedExpression = MLNAttributedExpression(expression, attributes: attributes)
|
|
// #-end-example-code
|
|
|
|
XCTAssertNotNil(attributedExpression)
|
|
}
|
|
|
|
func testMLNShapeSourceOptionClusterProperties() {
|
|
// #-example-code
|
|
let firstExpression = NSExpression(format: "sum:({$featureAccumulated, sumValue})")
|
|
let secondExpression = NSExpression(forKeyPath: "magnitude")
|
|
let clusterPropertiesDictionary = ["sumValue": [firstExpression, secondExpression]]
|
|
|
|
let options: [MLNShapeSourceOption: Any] = [.clustered: true,
|
|
.clusterProperties: clusterPropertiesDictionary]
|
|
// #-end-example-code
|
|
let geoJSON: [String: Any] = [
|
|
"type": "Feature",
|
|
"geometry": [
|
|
"coordinates": [
|
|
-77.00896639534831,
|
|
38.87031006108791,
|
|
0.0,
|
|
],
|
|
"type": "Point",
|
|
] as [String: Any],
|
|
"properties": [
|
|
"cluster": true,
|
|
"cluster_id": 123,
|
|
"point_count": 4567,
|
|
] as [String: Any],
|
|
]
|
|
|
|
let clusterShapeData = try! JSONSerialization.data(withJSONObject: geoJSON, options: [])
|
|
let shape = try! MLNShape(data: clusterShapeData, encoding: String.Encoding.utf8.rawValue)
|
|
let source = MLNShapeSource(identifier: "source", shape: shape, options: options)
|
|
mapView.style?.addSource(source)
|
|
}
|
|
|
|
// For testMLNMapView().
|
|
func myCustomFunction() {}
|
|
}
|