Ios '；数据'；此上下文中的类型查找不明确

我试图使用RealmSwift测试Realm数据库服务，但在函数addData和fetchData的模拟类中出现此错误：

“数据”对于此上下文中的类型查找不明确

在原始类中，此错误不会出现

模拟持久性：

@testable import AirWatcher
import RealmSwift

final class MockPersistenceService: PersistenceServiceProtocol {

func addStations(stations: [Station]) throws {
    <#code#>
}

func fetchStations() throws -> Results<Station> {
    <#code#>
}

func addSensors(sensors: [Sensor]) throws {
    <#code#>
}

func fetchSensors() throws -> Results<Sensor> {
    <#code#>
}

func addAddItem(addItem: AddItem) throws {
    <#code#>
}

func addAddItems(addItems: [AddItem]) throws {
    <#code#>
}

func deleteAddItem(addItem: AddItem) throws {
    <#code#>
}

func fetchAddItems() throws -> Results<AddItem> {
    <#code#>
}

func addData(data: [Data]) throws { //the problem appears here
    
}

func fetchData() throws -> Results<Data> { //the problem appears here

}

func addAirQualityIndex(air: [AirQualityIndex]) throws {
    <#code#>
}

func fetchAirQualityIndex() throws -> Results<AirQualityIndex> {
    <#code#>
}

}

@可测试导入空气切换器
导入RealmSwift
最后一个类MockPersistenceService:PersistenceServiceProtocol{
func addStations（stations:[站]）抛出{
}
func fetchStations（）抛出->结果{
}
func addSensors（传感器：[传感器]）抛出{
}
func fetchSensors（）抛出->结果{
}
func addItem（addItem:addItem）抛出{
}
func addItems（addItems:[AddItem]）抛出{
}
func deleteAddItem（addItem:addItem）抛出{
}
func fetchAddItems（）抛出->结果{
}
func addData（data:[data]）抛出{//问题出现在这里
}
func fetchData（）抛出->结果{//问题出现在这里
}
func addAirQualityIndex（air:[AirQualityIndex]）抛出{
}
func fetchAirQualityIndex（）抛出->结果{
}
}

持久性服务：

import RealmSwift

enum RuntimeError: Error {

case NoRealmSet
}

protocol PersistenceServiceProtocol {

func addStations(stations: [Station]) throws
func fetchStations() throws -> Results<Station>
func addSensors(sensors: [Sensor]) throws
func fetchSensors() throws -> Results<Sensor>
func addAddItem(addItem: AddItem) throws
func addAddItems(addItems: [AddItem]) throws
func deleteAddItem(addItem: AddItem) throws
func fetchAddItems() throws -> Results<AddItem>
func addData(data: [Data]) throws
func fetchData() throws -> Results<Data>
func addAirQualityIndex(air: [AirQualityIndex]) throws
func fetchAirQualityIndex() throws -> Results<AirQualityIndex>
}

final class PersistenceService: PersistenceServiceProtocol {

var realm: Realm?

    
func addStations(stations: [Station]) throws {
    let objects = stations.map { Station(value: $0)}
    autoreleasepool {
        do {
            realm = try Realm()
            try realm!.write {
                realm!.add(objects, update: Realm.UpdatePolicy.modified)
            }
        }
        catch RuntimeError.NoRealmSet
        {
            print("PERSISTENCE SERVICE: No Realm Database addStations")
        }
        catch let error as NSError
        {
            print(error.localizedDescription)
        }
    }
}

func addSensors(sensors: [Sensor]) throws {
    let objects = sensors.map { Sensor(value: $0)}
    autoreleasepool {
        do {
            realm = try Realm()
            try realm!.write {
                realm!.add(objects, update: Realm.UpdatePolicy.modified)
            }
        }
        catch RuntimeError.NoRealmSet
        {
            print("PERSISTENCE SERVICE: No Realm Database addSensors")
        }
        catch let error as NSError
        {
            print(error.localizedDescription)
        }
    }
}

func addData(data: [Data]) throws {
    let objects = data.map { Data(value: $0)}
    autoreleasepool {
        do {
            self.realm = try Realm()
            try self.realm!.write {
                self.realm!.add(objects, update: Realm.UpdatePolicy.modified)
            }
        }
        catch RuntimeError.NoRealmSet
        {
            print("PERSISTENCE SERVICE: No Realm Database addData")
        }
        catch let error as NSError
        {
            print(error.localizedDescription)
        }
    }
}

func addAirQualityIndex(air: [AirQualityIndex]) throws {
    let objects = air.map { AirQualityIndex(value: $0)}
    autoreleasepool {
        do {
            self.realm = try Realm()
            try self.realm!.write {
                self.realm!.add(objects, update: Realm.UpdatePolicy.modified)
            }
        }
        catch RuntimeError.NoRealmSet
        {
            print("PERSISTENCE SERVICE: No Realm Database addAirQualityIndex")
        }
        catch let error as NSError
        {
            print(error.localizedDescription)
        }
    }
}

func addAddItem(addItem: AddItem) throws {
    autoreleasepool {
    do {
        realm = try Realm()
        try realm!.write {
            realm!.add(addItem, update: Realm.UpdatePolicy.modified)
        }
    }
    catch RuntimeError.NoRealmSet
    {
        print("PERSISTENCE SERVICE: No Realm Database addAddItem")
    }
    catch let error as NSError
    {
        print(error.localizedDescription)
    }
    }
}

func addAddItems(addItems: [AddItem]) throws {
    let objects = addItems.map { AddItem(value: $0)}
    autoreleasepool {
        do {
            self.realm = try Realm()
            try self.realm!.write {
                self.realm!.add(objects, update: Realm.UpdatePolicy.modified)
            }
        }
        catch RuntimeError.NoRealmSet
        {
            print("PERSISTENCE SERVICE: No Realm Database addAddItems")
        }
        catch let error as NSError
        {
            print(error.localizedDescription)
        }
    }
}

func deleteAddItem(addItem: AddItem){
    let realm = try! Realm()
    try! realm.write {
        if let itemToDelete = realm.object(ofType: AddItem.self, forPrimaryKey: addItem.id) {
            realm.delete(itemToDelete)
        }
    }
}

func fetchAddItems() throws -> Results<AddItem> {
    do {
        let realm = try Realm()
        return realm.objects(AddItem.self)
    }
    catch {
        throw RuntimeError.NoRealmSet
    }
}
    
func fetchStations() throws -> Results<Station> {
        do {
            realm = try Realm()
            return realm!.objects(Station.self)
        }
        catch {
            throw RuntimeError.NoRealmSet
        }
    }

func fetchSensors() throws -> Results<Sensor> {
    do {
        realm = try Realm()
        return realm!.objects(Sensor.self)
    }
    catch {
        throw RuntimeError.NoRealmSet
    }
  }

func fetchData() throws -> Results<Data> {
    do {
        realm = try Realm()
        return realm!.objects(Data.self)
    }
    catch {
        throw RuntimeError.NoRealmSet
}
}

func fetchAirQualityIndex() throws -> Results<AirQualityIndex> {
    do {
        let realm = try Realm()
        return realm.objects(AirQualityIndex.self)
    }
    catch {
        throw RuntimeError.NoRealmSet
    }
}

导入RealmSwift
枚举运行时错误：错误{
诺雷姆塞特案例
}
协议持久性服务协议{
func addStations（stations:[站]）抛出
func fetchStations（）抛出->结果
func addSensors（传感器：[传感器]）抛出
func fetchSensors（）抛出->结果
func addItem（addItem:addItem）抛出
func addItems（addItems:[AddItem]）抛出
func deleteAddItem（addItem:addItem）抛出
func fetchAddItems（）抛出->结果
func addData（数据：[data]）抛出
func fetchData（）抛出->结果
func addAirQualityIndex（air:[AirQualityIndex]）抛出
func fetchAirQualityIndex（）抛出->结果
}
最后一个类PersistenceService:PersistenceServiceProtocol{
var领域：领域？
func addStations（stations:[站]）抛出{
让objects=stations.map{Station（值：$0）}
自动释放池{
做{
realm=try realm（）
试试！写{
realm！.add（对象，更新：realm.UpdatePolicy.modified）
}
}
捕获RuntimeError.NoRealmSet
{
打印（“持久性服务：无领域数据库添加站”）
}
将let错误捕获为NSError
{
打印（错误。本地化描述）
}
}
}
func addSensors（传感器：[传感器]）抛出{
让objects=sensors.map{Sensor（值：$0）}
自动释放池{
做{
realm=try realm（）
试试！写{
realm！.add（对象，更新：realm.UpdatePolicy.modified）
}
}
捕获RuntimeError.NoRealmSet
{
打印（“持久性服务：无领域数据库addSensors”）
}
将let错误捕获为NSError
{
打印（错误。本地化描述）
}
}
}
func addData（数据：[data]）抛出{
让objects=data.map{data（值：$0）}
自动释放池{
做{
self.realm=try realm（）
试试self.realm{
self.realm！.add（对象，更新：realm.UpdatePolicy.modified）
}
}
捕获RuntimeError.NoRealmSet
{
打印（“持久性服务：无领域数据库addData”）
}
将let错误捕获为NSError
{
打印（错误。本地化描述）
}
}
}
func addAirQualityIndex（air:[AirQualityIndex]）抛出{
让objects=air.map{AirQualityIndex（值：$0）}
自动释放池{
做{
self.realm=try realm（）
试试self.realm{
self.realm！.add（对象，更新：realm.UpdatePolicy.modified）
}
}
捕获RuntimeError.NoRealmSet
{
打印（“持久性服务：无领域数据库addAirQualityIndex”）
}
将let错误捕获为NSError
{
打印（错误。本地化描述）
}
}
}
func addItem（addItem:addItem）抛出{
自动释放池{
做{
realm=try realm（）
试试！写{
realm！.add（添加项，更新：realm.UpdatePolicy.modified）
}
}
捕获RuntimeError.NoRealmSet
{
打印（“持久性服务：无领域数据库addItem”）
}
将let错误捕获为NSError
{
打印（错误。本地化描述）
}
}
}
func addItems（addItems:[AddItem]）抛出{
让objects=addItems.map{AddItem（值：$0）}
自动释放池{
做{
self.realm=try realm（）
试试self.realm{
self.realm！.add（对象，更新：realm.UpdatePolicy.modified）
}
}
捕获RuntimeError.NoRealmSet
{
打印（“持久性服务：无领域数据库addItems”）
}
将let错误捕获为NSError
{
打印（错误。本地化描述）
}
}
}
func deleteAddItem（addItem:addItem）{
让realm=try！realm（）
试试看！写吧{
如果let itemtodelet=realm.object（类型：AddItem.self，forPrimaryKey:AddItem.id）{
realm.delete（itemToDelete）
}
}
}
func fetchAddItems（）抛出->结果{
做{
让realm=try realm（）
返回realm.objects（AddItem.self）
}
抓住{
抛出RuntimeError.NoRealmSet
}
}
func fetchStations（）抛出->结果{
做{
realm=try realm（）
返回域对象（Station.self）
}
抓住{
抛出RuntimeError.NoRealmSet
}
}
func fetchSensors（）抛出->结果{
做{
realm=try realm（）
返回域对象（Sensor.self）
}
抓住{
抛出RuntimeError.NoRealmSet
}
}
func fetchData（）抛出->结果{
做{
realm=try realm（）
返回realm！.objects（Data.self）
}
抓住{
抛出RuntimeError.NoRealmSet
}
}
F
import Foundation.NSURL
import RealmSwift

class Data: Object, Decodable, Identifiable {

@objc dynamic var id: Int = 0
@objc dynamic var stationId: Int = 0
@objc dynamic var key: String = ""
var values = List<Value>()

convenience init(id: Int, stationId: Int, key: String, values: [Value]) {
    self.init()
    self.id = id
    self.stationId = stationId
    self.key = key
    self.values.append(objectsIn: values)
}

private enum CodingKeys: String, CodingKey {
    case key = "key"
    case values = "values"
}

override class func primaryKey() -> String? {
    return "id"
}

@objc dynamic var date: String? = ""
var value = RealmOptional<Double>()

convenience init(date: String, value: RealmOptional<Double>) {
    self.init()
    self.date = date
    self.value = value
}