2214

Committed 10 Apr 2024 11:21PM UTC coverage: 91.813% (-0.8%) from 92.623%

Build # 2214

Build Type

push

Evergreen

Committed by

web-flow

Commit Message

Add missing availability checks for SecCopyErrorMessageString (#7577)

This requires iOS 11.3 and we currently target iOS 11.

Run Details

94848 of 175770 branches covered (53.96%)

7 of 22 new or added lines in 2 files covered. (31.82%)

1815 existing lines in 77 files now uncovered.

242945 of 264608 relevant lines covered (91.81%)

6136478.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.77

/src/realm/error_codes.cpp

/*************************************************************************
 *
 * Copyright 2021 Realm Inc.
 *
 * 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.
 *
 **************************************************************************/

#include <realm/error_codes.hpp>
#include <realm/util/assert.hpp>

#include <iostream>
#include <string_view>
#include <algorithm>
#include <cstring>

namespace realm {

ErrorCategory ErrorCodes::error_categories(Error code)
{
    switch (code) {
        case OK:
            break;

        case AddressSpaceExhausted:
        case BadVersion:
        case BrokenInvariant:
        case CallbackFailed:
        case MaximumFileSizeExceeded:
        case MultipleSyncAgents:
        case NoSubscriptionForWrite:
        case NotCloneable:
        case ObjectAlreadyExists:
        case OutOfDiskSpace:
        case OutOfMemory:
        case RangeError:
        case RuntimeError:
        case SchemaVersionMismatch:
        case UnsupportedFileFormatVersion:
        case OperationAborted:
            return ErrorCategory().set(ErrorCategory::runtime_error);

        case AutoClientResetFailed:
        case BadChangeset:
        case ConnectionClosed:
        case SubscriptionFailed:
        case SyncClientResetRequired:
        case SyncCompensatingWrite:
        case SyncPermissionDenied:
        case SyncProtocolInvariantFailed:
        case SyncServerPermissionsChanged:
        case SyncUserMismatch:
        case SyncWriteNotAllowed:
        case SyncLocalClockBeforeEpoch:
        case SyncSchemaMigrationError:
            return ErrorCategory().set(ErrorCategory::runtime_error).set(ErrorCategory::sync_error);

        case SyncConnectFailed:
        case SyncConnectTimeout:
        case SyncProtocolNegotiationFailed:
        case TlsHandshakeFailed:
            return ErrorCategory()
                .set(ErrorCategory::runtime_error)
                .set(ErrorCategory::websocket_error)
                .set(ErrorCategory::sync_error);

        case DecryptionFailed:
        case DeleteOnOpenRealm:
        case FileAlreadyExists:
        case FileFormatUpgradeRequired:
        case FileNotFound:
        case FileOperationFailed:
        case IncompatibleHistories:
        case IncompatibleLockFile:
        case IncompatibleSession:
        case InvalidDatabase:
        case PermissionDenied:
            return ErrorCategory().set(ErrorCategory::runtime_error).set(ErrorCategory::file_access);

        case SystemError:
            return ErrorCategory().set(ErrorCategory::runtime_error).set(ErrorCategory::system_error);

        case BrokenPromise:
        case ClosedRealm:
        case CrossTableLinkTarget:
        case IllegalOperation:
        case InvalidSchemaChange:
        case InvalidSchemaVersion:
        case InvalidTableRef:
        case InvalidatedObject:
        case KeyAlreadyUsed:
        case LogicError:
        case MigrationFailed:
        case MismatchedConfig:
        case NotSupported:
        case ReadOnlyDB:
        case SchemaMismatch:
        case SchemaValidationFailed:
        case SerializationError:
        case StaleAccessor:
        case WrongThread:
        case WrongTransactionState:
            return ErrorCategory().set(ErrorCategory::logic_error);

        case BadServerUrl:
        case IllegalCombination:
        case InvalidArgument:
        case InvalidDictionaryKey:
        case InvalidDictionaryValue:
        case InvalidEncryptionKey:
        case InvalidName:
        case InvalidProperty:
        case InvalidQuery:
        case InvalidQueryArg:
        case InvalidSortDescriptor:
        case KeyNotFound:
        case LimitExceeded:
        case MissingPrimaryKey:
        case MissingPropertyValue:
        case ModifyPrimaryKey:
        case NoSuchTable:
        case ObjectTypeMismatch:
        case OutOfBounds:
        case PropertyNotNullable:
        case ReadOnlyProperty:
        case SyntaxError:
        case TableNameInUse:
        case TopLevelObject:
        case TypeMismatch:
        case UnexpectedPrimaryKey:
            return ErrorCategory().set(ErrorCategory::invalid_argument).set(ErrorCategory::logic_error);

        case BadSyncPartitionValue:
        case InvalidSubscriptionQuery:
        case SyncInvalidSchemaChange:
        case WrongSyncType:
            return ErrorCategory()
                .set(ErrorCategory::invalid_argument)
                .set(ErrorCategory::logic_error)
                .set(ErrorCategory::sync_error);

        case CustomError:
            return ErrorCategory()
                .set(ErrorCategory::runtime_error)
                .set(ErrorCategory::app_error)
                .set(ErrorCategory::custom_error);

        case HTTPError:
            return ErrorCategory()
                .set(ErrorCategory::runtime_error)
                .set(ErrorCategory::app_error)
                .set(ErrorCategory::http_error);

        case ClientRedirectError:
        case ClientTooManyRedirects:
            return ErrorCategory()
                .set(ErrorCategory::runtime_error)
                .set(ErrorCategory::app_error)
                .set(ErrorCategory::client_error);

        case ClientUserNotFound:
        case ClientUserNotLoggedIn:
        case ClientUserAlreadyNamed:
            return ErrorCategory()
                .set(ErrorCategory::logic_error)
                .set(ErrorCategory::app_error)
                .set(ErrorCategory::client_error);

        case BadBsonParse:
        case BadToken:
        case MalformedJson:
        case MissingJsonKey:
            return ErrorCategory()
                .set(ErrorCategory::logic_error)
                .set(ErrorCategory::app_error)
                .set(ErrorCategory::json_error);

        case APIKeyAlreadyExists:
        case APIKeyNotFound:
        case AWSError:
        case AccountNameInUse:
        case AppServerError:
        case AppUnknownError:
        case ArgumentsNotAllowed:
        case AuthError:
        case AuthProviderAlreadyExists:
        case AuthProviderDuplicateName:
        case AuthProviderNotFound:
        case BadRequest:
        case DomainNotAllowed:
        case ExecutionTimeLimitExceeded:
        case FunctionAlreadyExists:
        case FunctionDuplicateName:
        case FunctionExecutionError:
        case FunctionInvalid:
        case FunctionNotFound:
        case FunctionSyntaxError:
        case GCMError:
        case IncomingWebhookAlreadyExists:
        case IncomingWebhookAuthFailed:
        case IncomingWebhookDuplicateName:
        case IncomingWebhookNotFound:
        case InternalServerError:
        case InvalidParameter:
        case InvalidPassword:
        case InvalidSession:
        case MaintenanceInProgress:
        case MissingAuthReq:
        case MissingParameter:
        case MongoDBError:
        case NoMatchingRuleFound:
        case NotCallable:
        case ReadSizeLimitExceeded:
        case RestrictedHost:
        case RuleAlreadyExists:
        case RuleDuplicateName:
        case RuleNotFound:
        case SchemaValidationFailedWrite:
        case ServiceAlreadyExists:
        case ServiceCommandNotFound:
        case ServiceNotFound:
        case ServiceTypeNotFound:
        case TwilioError:
        case UserAlreadyConfirmed:
        case UserAppDomainMismatch:
        case UserDisabled:
        case UserNotFound:
        case UserpassTokenInvalid:
        case InvalidServerResponse:
        case ValueAlreadyExists:
        case ValueDuplicateName:
        case ValueNotFound:
            return ErrorCategory()
                .set(ErrorCategory::runtime_error)
                .set(ErrorCategory::app_error)
                .set(ErrorCategory::service_error);

        case UnknownError:
            break;
    }
    return {};
}


struct MapElem {
    const char* name;
    ErrorCodes::Error code;
};

// Note: this array must be kept in sorted order
static const constexpr MapElem string_to_error_code[] = {
    {"APIKeyAlreadyExists", ErrorCodes::APIKeyAlreadyExists},
    {"APIKeyNotFound", ErrorCodes::APIKeyNotFound},
    {"AWSError", ErrorCodes::AWSError},
    {"AccountNameInUse", ErrorCodes::AccountNameInUse},
    {"AddressSpaceExhausted", ErrorCodes::AddressSpaceExhausted},
    {"AppServerError", ErrorCodes::AppServerError},
    {"AppUnknownError", ErrorCodes::AppUnknownError},
    {"ArgumentsNotAllowed", ErrorCodes::ArgumentsNotAllowed},
    {"AuthError", ErrorCodes::AuthError},
    {"AuthProviderAlreadyExists", ErrorCodes::AuthProviderAlreadyExists},
    {"AuthProviderDuplicateName", ErrorCodes::AuthProviderDuplicateName},
    {"AuthProviderNotFound", ErrorCodes::AuthProviderNotFound},
    {"AutoClientResetFailed", ErrorCodes::AutoClientResetFailed},
    {"BadBsonParse", ErrorCodes::BadBsonParse},
    {"BadChangeset", ErrorCodes::BadChangeset},
    {"BadRequest", ErrorCodes::BadRequest},
    {"BadServerUrl", ErrorCodes::BadServerUrl},
    {"BadSyncPartitionValue", ErrorCodes::BadSyncPartitionValue},
    {"BadToken", ErrorCodes::BadToken},
    {"BadVersion", ErrorCodes::BadVersion},
    {"BrokenInvariant", ErrorCodes::BrokenInvariant},
    {"BrokenPromise", ErrorCodes::BrokenPromise},
    {"CallbackFailed", ErrorCodes::CallbackFailed},
    {"ClientRedirectError", ErrorCodes::ClientRedirectError},
    {"ClientTooManyRedirects", ErrorCodes::ClientTooManyRedirects},
    {"ClientUserAlreadyNamed", ErrorCodes::ClientUserAlreadyNamed},
    {"ClientUserNotFound", ErrorCodes::ClientUserNotFound},
    {"ClientUserNotLoggedIn", ErrorCodes::ClientUserNotLoggedIn},
    {"ClosedRealm", ErrorCodes::ClosedRealm},
    {"ConnectionClosed", ErrorCodes::ConnectionClosed},
    {"CrossTableLinkTarget", ErrorCodes::CrossTableLinkTarget},
    {"CustomError", ErrorCodes::CustomError},
    {"DecryptionFailed", ErrorCodes::DecryptionFailed},
    {"DeleteOnOpenRealm", ErrorCodes::DeleteOnOpenRealm},
    {"DomainNotAllowed", ErrorCodes::DomainNotAllowed},
    {"ExecutionTimeLimitExceeded", ErrorCodes::ExecutionTimeLimitExceeded},
    {"FileAlreadyExists", ErrorCodes::FileAlreadyExists},
    {"FileFormatUpgradeRequired", ErrorCodes::FileFormatUpgradeRequired},
    {"FileNotFound", ErrorCodes::FileNotFound},
    {"FileOperationFailed", ErrorCodes::FileOperationFailed},
    {"FunctionAlreadyExists", ErrorCodes::FunctionAlreadyExists},
    {"FunctionDuplicateName", ErrorCodes::FunctionDuplicateName},
    {"FunctionExecutionError", ErrorCodes::FunctionExecutionError},
    {"FunctionInvalid", ErrorCodes::FunctionInvalid},
    {"FunctionNotFound", ErrorCodes::FunctionNotFound},
    {"FunctionSyntaxError", ErrorCodes::FunctionSyntaxError},
    {"GCMError", ErrorCodes::GCMError},
    {"HTTPError", ErrorCodes::HTTPError},
    {"IllegalOperation", ErrorCodes::IllegalOperation},
    {"IncomingWebhookAlreadyExists", ErrorCodes::IncomingWebhookAlreadyExists},
    {"IncomingWebhookAuthFailed", ErrorCodes::IncomingWebhookAuthFailed},
    {"IncomingWebhookDuplicateName", ErrorCodes::IncomingWebhookDuplicateName},
    {"IncomingWebhookNotFound", ErrorCodes::IncomingWebhookNotFound},
    {"IncompatibleHistories", ErrorCodes::IncompatibleHistories},
    {"IncompatibleLockFile", ErrorCodes::IncompatibleLockFile},
    {"IncompatibleSession", ErrorCodes::IncompatibleSession},
    {"InternalServerError", ErrorCodes::InternalServerError},
    {"InvalidArgument", ErrorCodes::InvalidArgument},
    {"InvalidCombination", ErrorCodes::IllegalCombination},
    {"InvalidDatabase", ErrorCodes::InvalidDatabase},
    {"InvalidDictionaryKey", ErrorCodes::InvalidDictionaryKey},
    {"InvalidDictionaryValue", ErrorCodes::InvalidDictionaryValue},
    {"InvalidEncryptionKey", ErrorCodes::InvalidEncryptionKey},
    {"InvalidName", ErrorCodes::InvalidName},
    {"InvalidParameter", ErrorCodes::InvalidParameter},
    {"InvalidPassword", ErrorCodes::InvalidPassword},
    {"InvalidProperty", ErrorCodes::InvalidProperty},
    {"InvalidQuery", ErrorCodes::InvalidQuery},
    {"InvalidQueryArg", ErrorCodes::InvalidQueryArg},
    {"InvalidSchemaChange", ErrorCodes::InvalidSchemaChange},
    {"InvalidSchemaVersion", ErrorCodes::InvalidSchemaVersion},
    {"InvalidServerResponse", ErrorCodes::InvalidServerResponse},
    {"InvalidSession", ErrorCodes::InvalidSession},
    {"InvalidSortDescriptor", ErrorCodes::InvalidSortDescriptor},
    {"InvalidSubscriptionQuery", ErrorCodes::InvalidSubscriptionQuery},
    {"InvalidTableRef", ErrorCodes::InvalidTableRef},
    {"InvalidatedObject", ErrorCodes::InvalidatedObject},
    {"KeyAlreadyUsed", ErrorCodes::KeyAlreadyUsed},
    {"KeyNotFound", ErrorCodes::KeyNotFound},
    {"LimitExceeded", ErrorCodes::LimitExceeded},
    {"LogicError", ErrorCodes::LogicError},
    {"MaintenanceInProgress", ErrorCodes::MaintenanceInProgress},
    {"MalformedJson", ErrorCodes::MalformedJson},
    {"MaximumFileSizeExceeded", ErrorCodes::MaximumFileSizeExceeded},
    {"MigrationFailed", ErrorCodes::MigrationFailed},
    {"MismatchedConfig", ErrorCodes::MismatchedConfig},
    {"MissingAuthReq", ErrorCodes::MissingAuthReq},
    {"MissingJsonKey", ErrorCodes::MissingJsonKey},
    {"MissingParameter", ErrorCodes::MissingParameter},
    {"MissingPrimaryKey", ErrorCodes::MissingPrimaryKey},
    {"MissingPropertyValue", ErrorCodes::MissingPropertyValue},
    {"ModifyPrimaryKey", ErrorCodes::ModifyPrimaryKey},
    {"MongoDBError", ErrorCodes::MongoDBError},
    {"MultipleSyncAgents", ErrorCodes::MultipleSyncAgents},
    {"NoMatchingRuleFound", ErrorCodes::NoMatchingRuleFound},
    {"NoSubscriptionForWrite", ErrorCodes::NoSubscriptionForWrite},
    {"NoSuchTable", ErrorCodes::NoSuchTable},
    {"NotCallable", ErrorCodes::NotCallable},
    {"NotCloneable", ErrorCodes::NotCloneable},
    {"NotSupported", ErrorCodes::NotSupported},
    {"OK", ErrorCodes::OK},
    {"ObjectAlreadyExists", ErrorCodes::ObjectAlreadyExists},
    {"ObjectTypeMismatch", ErrorCodes::ObjectTypeMismatch},
    {"OperationAborted", ErrorCodes::OperationAborted},
    {"OutOfBounds", ErrorCodes::OutOfBounds},
    {"OutOfDiskSpace", ErrorCodes::OutOfDiskSpace},
    {"OutOfMemory", ErrorCodes::OutOfMemory},
    {"PermissionDenied", ErrorCodes::PermissionDenied},
    {"PropertyNotNullable", ErrorCodes::PropertyNotNullable},
    {"RangeError", ErrorCodes::RangeError},
    {"ReadOnlyDB", ErrorCodes::ReadOnlyDB},
    {"ReadOnlyProperty", ErrorCodes::ReadOnlyProperty},
    {"ReadSizeLimitExceeded", ErrorCodes::ReadSizeLimitExceeded},
    {"RestrictedHost", ErrorCodes::RestrictedHost},
    {"RuleAlreadyExists", ErrorCodes::RuleAlreadyExists},
    {"RuleDuplicateName", ErrorCodes::RuleDuplicateName},
    {"RuleNotFound", ErrorCodes::RuleNotFound},
    {"RuntimeError", ErrorCodes::RuntimeError},
    {"SchemaMismatch", ErrorCodes::SchemaMismatch},
    {"SchemaValidationFailed", ErrorCodes::SchemaValidationFailed},
    {"SchemaValidationFailedWrite", ErrorCodes::SchemaValidationFailedWrite},
    {"SchemaVersionMismatch", ErrorCodes::SchemaVersionMismatch},
    {"SerializationError", ErrorCodes::SerializationError},
    {"ServiceAlreadyExists", ErrorCodes::ServiceAlreadyExists},
    {"ServiceCommandNotFound", ErrorCodes::ServiceCommandNotFound},
    {"ServiceNotFound", ErrorCodes::ServiceNotFound},
    {"ServiceTypeNotFound", ErrorCodes::ServiceTypeNotFound},
    {"StaleAccessor", ErrorCodes::StaleAccessor},
    {"SubscriptionFailed", ErrorCodes::SubscriptionFailed},
    {"SyncClientResetRequired", ErrorCodes::SyncClientResetRequired},
    {"SyncCompensatingWrite", ErrorCodes::SyncCompensatingWrite},
    {"SyncConnectFailed", ErrorCodes::SyncConnectFailed},
    {"SyncConnectTimeout", ErrorCodes::SyncConnectTimeout},
    {"SyncInvalidSchemaChange", ErrorCodes::SyncInvalidSchemaChange},
    {"SyncPermissionDenied", ErrorCodes::SyncPermissionDenied},
    {"SyncProtocolInvariantFailed", ErrorCodes::SyncProtocolInvariantFailed},
    {"SyncProtocolNegotiationFailed", ErrorCodes::SyncProtocolNegotiationFailed},
    {"SyncServerPermissionsChanged", ErrorCodes::SyncServerPermissionsChanged},
    {"SyncUserMismatch", ErrorCodes::SyncUserMismatch},
    {"SyncWriteNotAllowed", ErrorCodes::SyncWriteNotAllowed},
    {"SyntaxError", ErrorCodes::SyntaxError},
    {"SystemError", ErrorCodes::SystemError},
    {"TableNameInUse", ErrorCodes::TableNameInUse},
    {"TlsHandshakeFailed", ErrorCodes::TlsHandshakeFailed},
    {"TopLevelObject", ErrorCodes::TopLevelObject},
    {"TwilioError", ErrorCodes::TwilioError},
    {"TypeMismatch", ErrorCodes::TypeMismatch},
    {"UnexpectedPrimaryKey", ErrorCodes::UnexpectedPrimaryKey},
    {"UnsupportedFileFormatVersion", ErrorCodes::UnsupportedFileFormatVersion},
    {"UserAlreadyConfirmed", ErrorCodes::UserAlreadyConfirmed},
    {"UserAppDomainMismatch", ErrorCodes::UserAppDomainMismatch},
    {"UserDisabled", ErrorCodes::UserDisabled},
    {"UserNotFound", ErrorCodes::UserNotFound},
    {"UserpassTokenInvalid", ErrorCodes::UserpassTokenInvalid},
    {"ValueAlreadyExists", ErrorCodes::ValueAlreadyExists},
    {"ValueDuplicateName", ErrorCodes::ValueDuplicateName},
    {"ValueNotFound", ErrorCodes::ValueNotFound},
    {"WrongSyncType", ErrorCodes::WrongSyncType},
    {"WrongThread", ErrorCodes::WrongThread},
    {"WrongTransactionState", ErrorCodes::WrongTransactionState},
};

namespace {

class ErrorCodesMap {
public:
    ErrorCodesMap()
    {
#if REALM_DEBUG
        bool is_valid =
            std::is_sorted(std::begin(string_to_error_code), std::end(string_to_error_code), [](auto& a, auto& b) {
                if (strcmp(a.name, b.name) < 0) {
                    std::cout << a.name << " comes before " << b.name << std::endl;
                    return true;
                }
                return false;
            });

        REALM_ASSERT_DEBUG(is_valid);
#endif
    }

    ErrorCodes::Error operator[](std::string_view name)
    {
        auto it = std::lower_bound(std::begin(string_to_error_code), std::end(string_to_error_code), name,
                                   [](auto& ec_pair, auto name) {
                                       return strncmp(ec_pair.name, name.data(), name.size()) < 0;
                                   });
        if (it != std::end(string_to_error_code) && it->name == name) {
            return it->code;
        }
        return ErrorCodes::UnknownError;
    }

    std::string_view operator[](ErrorCodes::Error code)
    {
        for (auto [name, c] : string_to_error_code) {
            if (code == c) {
                return name;
            }
        }
        return "unknown";
    }
} error_codes_map;

} // namespace

std::string_view ErrorCodes::error_string(Error code)
{
    return error_codes_map[code];
}

ErrorCodes::Error ErrorCodes::from_string(std::string_view name)
{
    return error_codes_map[name];
}

std::vector<ErrorCodes::Error> ErrorCodes::get_all_codes()
{
    std::vector<ErrorCodes::Error> ret;
    for (auto it : string_to_error_code) {
        ret.push_back(it.code);
    }
    return ret;
}

std::vector<std::string_view> ErrorCodes::get_all_names()
{
    std::vector<std::string_view> ret;
    for (auto it : string_to_error_code) {
        ret.emplace_back(it.name);
    }
    return ret;
}

std::vector<std::pair<std::string_view, ErrorCodes::Error>> ErrorCodes::get_error_list()
{
    std::vector<std::pair<std::string_view, ErrorCodes::Error>> ret;
    for (auto it : string_to_error_code) {
        ret.emplace_back(std::make_pair(it.name, it.code));
    }
    return ret;
}

std::ostream& operator<<(std::ostream& stream, ErrorCodes::Error code)
{
    return stream << ErrorCodes::error_string(code);
}


} // namespace realm

1	/*************************************************************************
2	*
3	* Copyright 2021 Realm Inc.
4	*
5	* Licensed under the Apache License, Version 2.0 (the "License");
6	* you may not use this file except in compliance with the License.
7	* You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*
17	**************************************************************************/
18
19	#include <realm/error_codes.hpp>
20	#include <realm/util/assert.hpp>
21
22	#include <iostream>
23	#include <string_view>
24	#include <algorithm>
25	#include <cstring>
26
27	namespace realm {
28
29	ErrorCategory ErrorCodes::error_categories(Error code)
30	{	30,492✔
31	switch (code) {	30,492✔
32	case OK:	✔
33	break;	×
34
35	case AddressSpaceExhausted:	210✔
36	case BadVersion:	216✔
37	case BrokenInvariant:	228✔
38	case CallbackFailed:	270✔
39	case MaximumFileSizeExceeded:	276✔
40	case MultipleSyncAgents:	291✔
41	case NoSubscriptionForWrite:	300✔
42	case NotCloneable:	315✔
43	case ObjectAlreadyExists:	339✔
44	case OutOfDiskSpace:	345✔
45	case OutOfMemory:	351✔
46	case RangeError:	357✔
47	case RuntimeError:	390✔
48	case SchemaVersionMismatch:	396✔
49	case UnsupportedFileFormatVersion:	402✔
50	case OperationAborted:	408✔
51	return ErrorCategory().set(ErrorCategory::runtime_error);	408✔
52		204✔
53	case AutoClientResetFailed:	219✔
54	case BadChangeset:	102✔
55	case ConnectionClosed:	108✔
56	case SubscriptionFailed:	114✔
57	case SyncClientResetRequired:	123✔
58	case SyncCompensatingWrite:	132✔
59	case SyncPermissionDenied:	138✔
60	case SyncProtocolInvariantFailed:	144✔
61	case SyncServerPermissionsChanged:	150✔
62	case SyncUserMismatch:	156✔
63	case SyncWriteNotAllowed:	162✔
64	case SyncLocalClockBeforeEpoch:	162✔
65	case SyncSchemaMigrationError:	162✔
66	return ErrorCategory().set(ErrorCategory::runtime_error).set(ErrorCategory::sync_error);	162✔
67		81✔
68	case SyncConnectFailed:	87✔
69	case SyncConnectTimeout:	36✔
70	case SyncProtocolNegotiationFailed:	42✔
71	case TlsHandshakeFailed:	48✔
72	return ErrorCategory()	48✔
73	.set(ErrorCategory::runtime_error)	48✔
74	.set(ErrorCategory::websocket_error)	48✔
75	.set(ErrorCategory::sync_error);	48✔
76		24✔
77	case DecryptionFailed:	792✔
78	case DeleteOnOpenRealm:	804✔
79	case FileAlreadyExists:	894✔
80	case FileFormatUpgradeRequired:	942✔
81	case FileNotFound:	1,014✔
82	case FileOperationFailed:	1,098✔
83	case IncompatibleHistories:	1,122✔
84	case IncompatibleLockFile:	1,152✔
85	case IncompatibleSession:	1,164✔
86	case InvalidDatabase:	1,380✔
87	case PermissionDenied:	1,452✔
88	return ErrorCategory().set(ErrorCategory::runtime_error).set(ErrorCategory::file_access);	1,452✔
89		690✔
90	case SystemError:	714✔
91	return ErrorCategory().set(ErrorCategory::runtime_error).set(ErrorCategory::system_error);	48✔
92		690✔
93	case BrokenPromise:	4,803✔
94	case ClosedRealm:	4,875✔
95	case CrossTableLinkTarget:	4,890✔
96	case IllegalOperation:	7,221✔
97	case InvalidSchemaChange:	7,362✔
98	case InvalidSchemaVersion:	7,377✔
99	case InvalidTableRef:	7,404✔
100	case InvalidatedObject:	8,430✔
101	case KeyAlreadyUsed:	8,436✔
102	case LogicError:	8,442✔
103	case MigrationFailed:	8,463✔
104	case MismatchedConfig:	8,478✔
105	case NotSupported:	8,484✔
106	case ReadOnlyDB:	8,493✔
107	case SchemaMismatch:	8,625✔
108	case SchemaValidationFailed:	8,859✔
109	case SerializationError:	8,865✔
110	case StaleAccessor:	8,982✔
111	case WrongThread:	9,006✔
112	case WrongTransactionState:	9,603✔
113	return ErrorCategory().set(ErrorCategory::logic_error);	9,603✔
114		4,797✔
115	case BadServerUrl:	7,434✔
116	case IllegalCombination:	7,512✔
117	case InvalidArgument:	8,370✔
118	case InvalidDictionaryKey:	8,376✔
119	case InvalidDictionaryValue:	8,388✔
120	case InvalidEncryptionKey:	8,412✔
121	case InvalidName:	8,460✔
122	case InvalidProperty:	8,922✔
123	case InvalidQuery:	10,749✔
124	case InvalidQueryArg:	11,277✔
125	case InvalidSortDescriptor:	11,307✔
126	case KeyNotFound:	12,225✔
127	case LimitExceeded:	12,243✔
128	case MissingPrimaryKey:	12,258✔
129	case MissingPropertyValue:	12,267✔
130	case ModifyPrimaryKey:	12,279✔
131	case NoSuchTable:	12,384✔
132	case ObjectTypeMismatch:	12,528✔
133	case OutOfBounds:	13,404✔
134	case PropertyNotNullable:	13,542✔
135	case ReadOnlyProperty:	13,551✔
136	case SyntaxError:	14,679✔
137	case TableNameInUse:	14,697✔
138	case TopLevelObject:	14,703✔
139	case TypeMismatch:	14,856✔
140	case UnexpectedPrimaryKey:	14,874✔
141	return ErrorCategory().set(ErrorCategory::invalid_argument).set(ErrorCategory::logic_error);	14,874✔
142		7,428✔
143	case BadSyncPartitionValue:	7,434✔
144	case InvalidSubscriptionQuery:	36✔
145	case SyncInvalidSchemaChange:	42✔
146	case WrongSyncType:	48✔
147	return ErrorCategory()	48✔
148	.set(ErrorCategory::invalid_argument)	48✔
149	.set(ErrorCategory::logic_error)	48✔
150	.set(ErrorCategory::sync_error);	48✔
151		24✔
152	case CustomError:	114✔
153	return ErrorCategory()	114✔
154	.set(ErrorCategory::runtime_error)	114✔
155	.set(ErrorCategory::app_error)	114✔
156	.set(ErrorCategory::custom_error);	114✔
157		24✔
158	case HTTPError:	486✔
159	return ErrorCategory()	486✔
160	.set(ErrorCategory::runtime_error)	486✔
161	.set(ErrorCategory::app_error)	486✔
162	.set(ErrorCategory::http_error);	486✔
163		24✔
164	case ClientRedirectError:	117✔
165	case ClientTooManyRedirects:	156✔
166	return ErrorCategory()	156✔
167	.set(ErrorCategory::runtime_error)	156✔
168	.set(ErrorCategory::app_error)	156✔
169	.set(ErrorCategory::client_error);	156✔
170		78✔
171	case ClientUserNotFound:	108✔
172	case ClientUserNotLoggedIn:	114✔
173	case ClientUserAlreadyNamed:	123✔
174	return ErrorCategory()	123✔
175	.set(ErrorCategory::logic_error)	123✔
176	.set(ErrorCategory::app_error)	123✔
177	.set(ErrorCategory::client_error);	123✔
178		60✔
179	case BadBsonParse:	144✔
180	case BadToken:	189✔
181	case MalformedJson:	213✔
182	case MissingJsonKey:	222✔
183	return ErrorCategory()	222✔
184	.set(ErrorCategory::logic_error)	222✔
185	.set(ErrorCategory::app_error)	222✔
186	.set(ErrorCategory::json_error);	222✔
187		111✔
188	case APIKeyAlreadyExists:	1,383✔
189	case APIKeyNotFound:	1,524✔
190	case AWSError:	1,533✔
191	case AccountNameInUse:	1,548✔
192	case AppServerError:	1,839✔
193	case AppUnknownError:	2,007✔
194	case ArgumentsNotAllowed:	2,016✔
195	case AuthError:	2,028✔
196	case AuthProviderAlreadyExists:	2,037✔
197	case AuthProviderDuplicateName:	2,046✔
198	case AuthProviderNotFound:	2,055✔
199	case BadRequest:	2,094✔
200	case DomainNotAllowed:	2,103✔
201	case ExecutionTimeLimitExceeded:	2,112✔
202	case FunctionAlreadyExists:	2,121✔
203	case FunctionDuplicateName:	2,130✔
204	case FunctionExecutionError:	2,139✔
205	case FunctionInvalid:	2,148✔
206	case FunctionNotFound:	2,157✔
207	case FunctionSyntaxError:	2,166✔
208	case GCMError:	2,175✔
209	case IncomingWebhookAlreadyExists:	2,184✔
210	case IncomingWebhookAuthFailed:	2,193✔
211	case IncomingWebhookDuplicateName:	2,202✔
212	case IncomingWebhookNotFound:	2,211✔
213	case InternalServerError:	2,220✔
214	case InvalidParameter:	2,241✔
215	case InvalidPassword:	2,262✔
216	case InvalidSession:	2,325✔
217	case MaintenanceInProgress:	2,349✔
218	case MissingAuthReq:	2,358✔
219	case MissingParameter:	2,367✔
220	case MongoDBError:	2,466✔
221	case NoMatchingRuleFound:	2,475✔
222	case NotCallable:	2,484✔
223	case ReadSizeLimitExceeded:	2,493✔
224	case RestrictedHost:	2,502✔
225	case RuleAlreadyExists:	2,511✔
226	case RuleDuplicateName:	2,520✔
227	case RuleNotFound:	2,529✔
228	case SchemaValidationFailedWrite:	2,574✔
229	case ServiceAlreadyExists:	2,583✔
230	case ServiceCommandNotFound:	2,592✔
231	case ServiceNotFound:	2,613✔
232	case ServiceTypeNotFound:	2,622✔
233	case TwilioError:	2,631✔
234	case UserAlreadyConfirmed:	2,652✔
235	case UserAppDomainMismatch:	2,661✔
236	case UserDisabled:	2,676✔
237	case UserNotFound:	2,703✔
238	case UserpassTokenInvalid:	2,712✔
239	case InvalidServerResponse:	2,721✔
240	case ValueAlreadyExists:	2,730✔
241	case ValueDuplicateName:	2,739✔
242	case ValueNotFound:	2,748✔
243	return ErrorCategory()	2,748✔
244	.set(ErrorCategory::runtime_error)	2,748✔
245	.set(ErrorCategory::app_error)	2,748✔
246	.set(ErrorCategory::service_error);	2,748✔
247		1,374✔
248	case UnknownError:	1,374✔
UNCOV 249	break;	×
UNCOV 250	}	×
UNCOV 251	return {};	×
UNCOV 252	}	×
253
254
255	struct MapElem {
256	const char* name;
257	ErrorCodes::Error code;
258	};
259
260	// Note: this array must be kept in sorted order
261	static const constexpr MapElem string_to_error_code[] = {
262	{"APIKeyAlreadyExists", ErrorCodes::APIKeyAlreadyExists},
263	{"APIKeyNotFound", ErrorCodes::APIKeyNotFound},
264	{"AWSError", ErrorCodes::AWSError},
265	{"AccountNameInUse", ErrorCodes::AccountNameInUse},
266	{"AddressSpaceExhausted", ErrorCodes::AddressSpaceExhausted},
267	{"AppServerError", ErrorCodes::AppServerError},
268	{"AppUnknownError", ErrorCodes::AppUnknownError},
269	{"ArgumentsNotAllowed", ErrorCodes::ArgumentsNotAllowed},
270	{"AuthError", ErrorCodes::AuthError},
271	{"AuthProviderAlreadyExists", ErrorCodes::AuthProviderAlreadyExists},
272	{"AuthProviderDuplicateName", ErrorCodes::AuthProviderDuplicateName},
273	{"AuthProviderNotFound", ErrorCodes::AuthProviderNotFound},
274	{"AutoClientResetFailed", ErrorCodes::AutoClientResetFailed},
275	{"BadBsonParse", ErrorCodes::BadBsonParse},
276	{"BadChangeset", ErrorCodes::BadChangeset},
277	{"BadRequest", ErrorCodes::BadRequest},
278	{"BadServerUrl", ErrorCodes::BadServerUrl},
279	{"BadSyncPartitionValue", ErrorCodes::BadSyncPartitionValue},
280	{"BadToken", ErrorCodes::BadToken},
281	{"BadVersion", ErrorCodes::BadVersion},
282	{"BrokenInvariant", ErrorCodes::BrokenInvariant},
283	{"BrokenPromise", ErrorCodes::BrokenPromise},
284	{"CallbackFailed", ErrorCodes::CallbackFailed},
285	{"ClientRedirectError", ErrorCodes::ClientRedirectError},
286	{"ClientTooManyRedirects", ErrorCodes::ClientTooManyRedirects},
287	{"ClientUserAlreadyNamed", ErrorCodes::ClientUserAlreadyNamed},
288	{"ClientUserNotFound", ErrorCodes::ClientUserNotFound},
289	{"ClientUserNotLoggedIn", ErrorCodes::ClientUserNotLoggedIn},
290	{"ClosedRealm", ErrorCodes::ClosedRealm},
291	{"ConnectionClosed", ErrorCodes::ConnectionClosed},
292	{"CrossTableLinkTarget", ErrorCodes::CrossTableLinkTarget},
293	{"CustomError", ErrorCodes::CustomError},
294	{"DecryptionFailed", ErrorCodes::DecryptionFailed},
295	{"DeleteOnOpenRealm", ErrorCodes::DeleteOnOpenRealm},
296	{"DomainNotAllowed", ErrorCodes::DomainNotAllowed},
297	{"ExecutionTimeLimitExceeded", ErrorCodes::ExecutionTimeLimitExceeded},
298	{"FileAlreadyExists", ErrorCodes::FileAlreadyExists},
299	{"FileFormatUpgradeRequired", ErrorCodes::FileFormatUpgradeRequired},
300	{"FileNotFound", ErrorCodes::FileNotFound},
301	{"FileOperationFailed", ErrorCodes::FileOperationFailed},
302	{"FunctionAlreadyExists", ErrorCodes::FunctionAlreadyExists},
303	{"FunctionDuplicateName", ErrorCodes::FunctionDuplicateName},
304	{"FunctionExecutionError", ErrorCodes::FunctionExecutionError},
305	{"FunctionInvalid", ErrorCodes::FunctionInvalid},
306	{"FunctionNotFound", ErrorCodes::FunctionNotFound},
307	{"FunctionSyntaxError", ErrorCodes::FunctionSyntaxError},
308	{"GCMError", ErrorCodes::GCMError},
309	{"HTTPError", ErrorCodes::HTTPError},
310	{"IllegalOperation", ErrorCodes::IllegalOperation},
311	{"IncomingWebhookAlreadyExists", ErrorCodes::IncomingWebhookAlreadyExists},
312	{"IncomingWebhookAuthFailed", ErrorCodes::IncomingWebhookAuthFailed},
313	{"IncomingWebhookDuplicateName", ErrorCodes::IncomingWebhookDuplicateName},
314	{"IncomingWebhookNotFound", ErrorCodes::IncomingWebhookNotFound},
315	{"IncompatibleHistories", ErrorCodes::IncompatibleHistories},
316	{"IncompatibleLockFile", ErrorCodes::IncompatibleLockFile},
317	{"IncompatibleSession", ErrorCodes::IncompatibleSession},
318	{"InternalServerError", ErrorCodes::InternalServerError},
319	{"InvalidArgument", ErrorCodes::InvalidArgument},
320	{"InvalidCombination", ErrorCodes::IllegalCombination},
321	{"InvalidDatabase", ErrorCodes::InvalidDatabase},
322	{"InvalidDictionaryKey", ErrorCodes::InvalidDictionaryKey},
323	{"InvalidDictionaryValue", ErrorCodes::InvalidDictionaryValue},
324	{"InvalidEncryptionKey", ErrorCodes::InvalidEncryptionKey},
325	{"InvalidName", ErrorCodes::InvalidName},
326	{"InvalidParameter", ErrorCodes::InvalidParameter},
327	{"InvalidPassword", ErrorCodes::InvalidPassword},
328	{"InvalidProperty", ErrorCodes::InvalidProperty},
329	{"InvalidQuery", ErrorCodes::InvalidQuery},
330	{"InvalidQueryArg", ErrorCodes::InvalidQueryArg},
331	{"InvalidSchemaChange", ErrorCodes::InvalidSchemaChange},
332	{"InvalidSchemaVersion", ErrorCodes::InvalidSchemaVersion},
333	{"InvalidServerResponse", ErrorCodes::InvalidServerResponse},
334	{"InvalidSession", ErrorCodes::InvalidSession},
335	{"InvalidSortDescriptor", ErrorCodes::InvalidSortDescriptor},
336	{"InvalidSubscriptionQuery", ErrorCodes::InvalidSubscriptionQuery},
337	{"InvalidTableRef", ErrorCodes::InvalidTableRef},
338	{"InvalidatedObject", ErrorCodes::InvalidatedObject},
339	{"KeyAlreadyUsed", ErrorCodes::KeyAlreadyUsed},
340	{"KeyNotFound", ErrorCodes::KeyNotFound},
341	{"LimitExceeded", ErrorCodes::LimitExceeded},
342	{"LogicError", ErrorCodes::LogicError},
343	{"MaintenanceInProgress", ErrorCodes::MaintenanceInProgress},
344	{"MalformedJson", ErrorCodes::MalformedJson},
345	{"MaximumFileSizeExceeded", ErrorCodes::MaximumFileSizeExceeded},
346	{"MigrationFailed", ErrorCodes::MigrationFailed},
347	{"MismatchedConfig", ErrorCodes::MismatchedConfig},
348	{"MissingAuthReq", ErrorCodes::MissingAuthReq},
349	{"MissingJsonKey", ErrorCodes::MissingJsonKey},
350	{"MissingParameter", ErrorCodes::MissingParameter},
351	{"MissingPrimaryKey", ErrorCodes::MissingPrimaryKey},
352	{"MissingPropertyValue", ErrorCodes::MissingPropertyValue},
353	{"ModifyPrimaryKey", ErrorCodes::ModifyPrimaryKey},
354	{"MongoDBError", ErrorCodes::MongoDBError},
355	{"MultipleSyncAgents", ErrorCodes::MultipleSyncAgents},
356	{"NoMatchingRuleFound", ErrorCodes::NoMatchingRuleFound},
357	{"NoSubscriptionForWrite", ErrorCodes::NoSubscriptionForWrite},
358	{"NoSuchTable", ErrorCodes::NoSuchTable},
359	{"NotCallable", ErrorCodes::NotCallable},
360	{"NotCloneable", ErrorCodes::NotCloneable},
361	{"NotSupported", ErrorCodes::NotSupported},
362	{"OK", ErrorCodes::OK},
363	{"ObjectAlreadyExists", ErrorCodes::ObjectAlreadyExists},
364	{"ObjectTypeMismatch", ErrorCodes::ObjectTypeMismatch},
365	{"OperationAborted", ErrorCodes::OperationAborted},
366	{"OutOfBounds", ErrorCodes::OutOfBounds},
367	{"OutOfDiskSpace", ErrorCodes::OutOfDiskSpace},
368	{"OutOfMemory", ErrorCodes::OutOfMemory},
369	{"PermissionDenied", ErrorCodes::PermissionDenied},
370	{"PropertyNotNullable", ErrorCodes::PropertyNotNullable},
371	{"RangeError", ErrorCodes::RangeError},
372	{"ReadOnlyDB", ErrorCodes::ReadOnlyDB},
373	{"ReadOnlyProperty", ErrorCodes::ReadOnlyProperty},
374	{"ReadSizeLimitExceeded", ErrorCodes::ReadSizeLimitExceeded},
375	{"RestrictedHost", ErrorCodes::RestrictedHost},
376	{"RuleAlreadyExists", ErrorCodes::RuleAlreadyExists},
377	{"RuleDuplicateName", ErrorCodes::RuleDuplicateName},
378	{"RuleNotFound", ErrorCodes::RuleNotFound},
379	{"RuntimeError", ErrorCodes::RuntimeError},
380	{"SchemaMismatch", ErrorCodes::SchemaMismatch},
381	{"SchemaValidationFailed", ErrorCodes::SchemaValidationFailed},
382	{"SchemaValidationFailedWrite", ErrorCodes::SchemaValidationFailedWrite},
383	{"SchemaVersionMismatch", ErrorCodes::SchemaVersionMismatch},
384	{"SerializationError", ErrorCodes::SerializationError},
385	{"ServiceAlreadyExists", ErrorCodes::ServiceAlreadyExists},
386	{"ServiceCommandNotFound", ErrorCodes::ServiceCommandNotFound},
387	{"ServiceNotFound", ErrorCodes::ServiceNotFound},
388	{"ServiceTypeNotFound", ErrorCodes::ServiceTypeNotFound},
389	{"StaleAccessor", ErrorCodes::StaleAccessor},
390	{"SubscriptionFailed", ErrorCodes::SubscriptionFailed},
391	{"SyncClientResetRequired", ErrorCodes::SyncClientResetRequired},
392	{"SyncCompensatingWrite", ErrorCodes::SyncCompensatingWrite},
393	{"SyncConnectFailed", ErrorCodes::SyncConnectFailed},
394	{"SyncConnectTimeout", ErrorCodes::SyncConnectTimeout},
395	{"SyncInvalidSchemaChange", ErrorCodes::SyncInvalidSchemaChange},
396	{"SyncPermissionDenied", ErrorCodes::SyncPermissionDenied},
397	{"SyncProtocolInvariantFailed", ErrorCodes::SyncProtocolInvariantFailed},
398	{"SyncProtocolNegotiationFailed", ErrorCodes::SyncProtocolNegotiationFailed},
399	{"SyncServerPermissionsChanged", ErrorCodes::SyncServerPermissionsChanged},
400	{"SyncUserMismatch", ErrorCodes::SyncUserMismatch},
401	{"SyncWriteNotAllowed", ErrorCodes::SyncWriteNotAllowed},
402	{"SyntaxError", ErrorCodes::SyntaxError},
403	{"SystemError", ErrorCodes::SystemError},
404	{"TableNameInUse", ErrorCodes::TableNameInUse},
405	{"TlsHandshakeFailed", ErrorCodes::TlsHandshakeFailed},
406	{"TopLevelObject", ErrorCodes::TopLevelObject},
407	{"TwilioError", ErrorCodes::TwilioError},
408	{"TypeMismatch", ErrorCodes::TypeMismatch},
409	{"UnexpectedPrimaryKey", ErrorCodes::UnexpectedPrimaryKey},
410	{"UnsupportedFileFormatVersion", ErrorCodes::UnsupportedFileFormatVersion},
411	{"UserAlreadyConfirmed", ErrorCodes::UserAlreadyConfirmed},
412	{"UserAppDomainMismatch", ErrorCodes::UserAppDomainMismatch},
413	{"UserDisabled", ErrorCodes::UserDisabled},
414	{"UserNotFound", ErrorCodes::UserNotFound},
415	{"UserpassTokenInvalid", ErrorCodes::UserpassTokenInvalid},
416	{"ValueAlreadyExists", ErrorCodes::ValueAlreadyExists},
417	{"ValueDuplicateName", ErrorCodes::ValueDuplicateName},
418	{"ValueNotFound", ErrorCodes::ValueNotFound},
419	{"WrongSyncType", ErrorCodes::WrongSyncType},
420	{"WrongThread", ErrorCodes::WrongThread},
421	{"WrongTransactionState", ErrorCodes::WrongTransactionState},
422	};
423
424	namespace {
425
426	class ErrorCodesMap {
427	public:
428	ErrorCodesMap()
429	{	24✔
430	#if REALM_DEBUG	24✔
431	bool is_valid =	24✔
432	std::is_sorted(std::begin(string_to_error_code), std::end(string_to_error_code), [](auto& a, auto& b) {	3,816✔
433	if (strcmp(a.name, b.name) < 0) {	3,816✔
UNCOV 434	std::cout << a.name << " comes before " << b.name << std::endl;	×
UNCOV 435	return true;	×
UNCOV 436	}	×
437	return false;	3,816✔
438	});	3,816✔
439		12✔
440	REALM_ASSERT_DEBUG(is_valid);	24✔
441	#endif	24✔
442	}	24✔
443
444	ErrorCodes::Error operator[](std::string_view name)
445	{	3,288✔
446	auto it = std::lower_bound(std::begin(string_to_error_code), std::end(string_to_error_code), name,	3,288✔
447	[](auto& ec_pair, auto name) {	24,468✔
448	return strncmp(ec_pair.name, name.data(), name.size()) < 0;	24,468✔
449	});	24,468✔
450	if (it != std::end(string_to_error_code) && it->name == name) {	3,288✔
451	return it->code;	3,264✔
452	}	3,264✔
453	return ErrorCodes::UnknownError;	24✔
454	}	24✔
455
456	std::string_view operator[](ErrorCodes::Error code)
457	{	4,689✔
458	for (auto [name, c] : string_to_error_code) {	306,261✔
459	if (code == c) {	306,261✔
460	return name;	4,683✔
461	}	4,683✔
462	}	306,261✔
463	return "unknown";	2,436✔
464	}	4,689✔
465	} error_codes_map;
466
467	} // namespace
468
469	std::string_view ErrorCodes::error_string(Error code)
470	{	4,689✔
471	return error_codes_map[code];	4,689✔
472	}	4,689✔
473
474	ErrorCodes::Error ErrorCodes::from_string(std::string_view name)
475	{	3,288✔
476	return error_codes_map[name];	3,288✔
477	}	3,288✔
478
479	std::vector<ErrorCodes::Error> ErrorCodes::get_all_codes()
480	{	6✔
481	std::vector<ErrorCodes::Error> ret;	6✔
482	for (auto it : string_to_error_code) {	960✔
483	ret.push_back(it.code);	960✔
484	}	960✔
485	return ret;	6✔
486	}	6✔
487
488	std::vector<std::string_view> ErrorCodes::get_all_names()
489	{	6✔
490	std::vector<std::string_view> ret;	6✔
491	for (auto it : string_to_error_code) {	960✔
492	ret.emplace_back(it.name);	960✔
493	}	960✔
494	return ret;	6✔
495	}	6✔
496
497	std::vector<std::pair<std::string_view, ErrorCodes::Error>> ErrorCodes::get_error_list()
498	{	6✔
499	std::vector<std::pair<std::string_view, ErrorCodes::Error>> ret;	6✔
500	for (auto it : string_to_error_code) {	960✔
501	ret.emplace_back(std::make_pair(it.name, it.code));	960✔
502	}	960✔
503	return ret;	6✔
504	}	6✔
505
506	std::ostream& operator<<(std::ostream& stream, ErrorCodes::Error code)
UNCOV 507	{	×
UNCOV 508	return stream << ErrorCodes::error_string(code);	×
UNCOV 509	}	×
510
511
512	} // namespace realm

realm / realm-core / 2214

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous