1713

Committed 29 Sep 2023 04:21PM UTC coverage: 91.188% (-0.01%) from 91.2%

Build # 1713

Build Type

push

Evergreen

Committed by

web-flow

Commit Message

Merge pull request #7011 from realm/release/13.22.0

core v13.22.0

Run Details

95870 of 175738 branches covered (0.0%)

232455 of 254918 relevant lines covered (91.19%)

6777515.11 hits per line

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

97.53

/src/realm/array_key.cpp

/*************************************************************************
 *
 * Copyright 2016 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/array_key.hpp>
#include <realm/table.hpp>

namespace realm {

// This is used for linklists
template <>
void ArrayKeyBase<0>::verify() const
{
#ifdef REALM_DEBUG
    Array::verify();
    // We have to get parent until we reach the containing cluster
    auto parent = get_parent();
    size_t origin_obj_ndx;
    size_t origin_col_ndx = get_ndx_in_parent();
    Cluster* cluster = nullptr;
    do {
        REALM_ASSERT(parent);
        auto arr = dynamic_cast<Array*>(parent);
        REALM_ASSERT(arr);
        parent = arr->get_parent();
        // When we reach the cluster, the previous value of
        // origin_col_ndx will be the object index in the cluster.
        origin_obj_ndx = origin_col_ndx;
        // When we reach the cluster, arr will point to the ArrayRef leaf and the
        // origin_col_ndx will give the position in the cluster array.
        origin_col_ndx = arr->get_ndx_in_parent();
        cluster = dynamic_cast<Cluster*>(parent);
    } while (parent && !cluster);

    REALM_ASSERT(cluster);
    const Table* origin_table = cluster->get_owning_table();
    ObjKey origin_key = cluster->get_real_key(origin_obj_ndx);
    ColKey link_col_key = cluster->get_col_key(origin_col_ndx);

    TableRef target_table = origin_table->get_opposite_table(link_col_key);

    auto verify_link = [origin_table, link_col_key, origin_key](const Obj& target_obj) {
        auto cnt = target_obj.get_backlink_count(*origin_table, link_col_key);
        for (size_t i = 0; i < cnt; i++) {
            if (target_obj.get_backlink(*origin_table, link_col_key, i) == origin_key)
                return;
        }
        REALM_ASSERT(false);
    };

    // Verify that forward link has a corresponding backlink
    for (size_t i = 0; i < size(); ++i) {
        if (ObjKey target_key = get(i)) {
            auto target_obj = target_key.is_unresolved() ? target_table->try_get_tombstone(target_key)
                                                         : target_table->try_get_object(target_key);
            REALM_ASSERT(target_obj);
            verify_link(target_obj);
        }
    }
#endif
}

// This is used for single links
template <>
void ArrayKeyBase<1>::verify() const
{
#ifdef REALM_DEBUG
    Array::verify();
    REALM_ASSERT(dynamic_cast<Cluster*>(get_parent()));
    auto cluster = static_cast<Cluster*>(get_parent());
    const Table* origin_table = cluster->get_owning_table();
    ColKey link_col_key = cluster->get_col_key(get_ndx_in_parent());

    ConstTableRef target_table = origin_table->get_opposite_table(link_col_key);

    auto verify_link = [origin_table, link_col_key](const Obj& target_obj, ObjKey origin_key) {
        auto cnt = target_obj.get_backlink_count(*origin_table, link_col_key);
        for (size_t i = 0; i < cnt; i++) {
            if (target_obj.get_backlink(*origin_table, link_col_key, i) == origin_key)
                return;
        }
        REALM_ASSERT(false);
    };

    // Verify that forward link has a corresponding backlink
    for (size_t i = 0; i < size(); ++i) {
        if (ObjKey target_key = get(i)) {
            ObjKey origin_key = cluster->get_real_key(i);

            auto target_obj = target_key.is_unresolved() ? target_table->try_get_tombstone(target_key)
                                                         : target_table->try_get_object(target_key);
            REALM_ASSERT(target_obj);
            verify_link(target_obj, origin_key);
        }
    }
#endif
}

} // namespace realm

1	/*************************************************************************
2	*
3	* Copyright 2016 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/array_key.hpp>
20	#include <realm/table.hpp>
21
22	namespace realm {
23
24	// This is used for linklists
25	template <>
26	void ArrayKeyBase<0>::verify() const
27	{	2,016✔
28	#ifdef REALM_DEBUG	2,016✔
29	Array::verify();	2,016✔
30	// We have to get parent until we reach the containing cluster	1,008✔
31	auto parent = get_parent();	2,016✔
32	size_t origin_obj_ndx;	2,016✔
33	size_t origin_col_ndx = get_ndx_in_parent();	2,016✔
34	Cluster* cluster = nullptr;	2,016✔
35	do {	2,016✔
36	REALM_ASSERT(parent);	2,016✔
37	auto arr = dynamic_cast<Array*>(parent);	2,016✔
38	REALM_ASSERT(arr);	2,016✔
39	parent = arr->get_parent();	2,016✔
40	// When we reach the cluster, the previous value of	1,008✔
41	// origin_col_ndx will be the object index in the cluster.	1,008✔
42	origin_obj_ndx = origin_col_ndx;	2,016✔
43	// When we reach the cluster, arr will point to the ArrayRef leaf and the	1,008✔
44	// origin_col_ndx will give the position in the cluster array.	1,008✔
45	origin_col_ndx = arr->get_ndx_in_parent();	2,016✔
46	cluster = dynamic_cast<Cluster*>(parent);	2,016✔
47	} while (parent && !cluster);	2,016✔
48		1,008✔
49	REALM_ASSERT(cluster);	2,016✔
50	const Table* origin_table = cluster->get_owning_table();	2,016✔
51	ObjKey origin_key = cluster->get_real_key(origin_obj_ndx);	2,016✔
52	ColKey link_col_key = cluster->get_col_key(origin_col_ndx);	2,016✔
53		1,008✔
54	TableRef target_table = origin_table->get_opposite_table(link_col_key);	2,016✔
55		1,008✔
56	auto verify_link = [origin_table, link_col_key, origin_key](const Obj& target_obj) {	10,092✔
57	auto cnt = target_obj.get_backlink_count(*origin_table, link_col_key);	10,092✔
58	for (size_t i = 0; i < cnt; i++) {	10,692✔
59	if (target_obj.get_backlink(*origin_table, link_col_key, i) == origin_key)	10,692✔
60	return;	10,092✔
61	}	10,692✔
62	REALM_ASSERT(false);	5,046✔
63	};	×
64		1,008✔
65	// Verify that forward link has a corresponding backlink	1,008✔
66	for (size_t i = 0; i < size(); ++i) {	12,108✔
67	if (ObjKey target_key = get(i)) {	10,092✔
68	auto target_obj = target_key.is_unresolved() ? target_table->try_get_tombstone(target_key)	5,103✔
69	: target_table->try_get_object(target_key);	10,035✔
70	REALM_ASSERT(target_obj);	10,092✔
71	verify_link(target_obj);	10,092✔
72	}	10,092✔
73	}	10,092✔
74	#endif	2,016✔
75	}	2,016✔
76
77	// This is used for single links
78	template <>
79	void ArrayKeyBase<1>::verify() const
80	{	1,104✔
81	#ifdef REALM_DEBUG	1,104✔
82	Array::verify();	1,104✔
83	REALM_ASSERT(dynamic_cast<Cluster*>(get_parent()));	1,104✔
84	auto cluster = static_cast<Cluster*>(get_parent());	1,104✔
85	const Table* origin_table = cluster->get_owning_table();	1,104✔
86	ColKey link_col_key = cluster->get_col_key(get_ndx_in_parent());	1,104✔
87		552✔
88	ConstTableRef target_table = origin_table->get_opposite_table(link_col_key);	1,104✔
89		552✔
90	auto verify_link = [origin_table, link_col_key](const Obj& target_obj, ObjKey origin_key) {	996✔
91	auto cnt = target_obj.get_backlink_count(*origin_table, link_col_key);	888✔
92	for (size_t i = 0; i < cnt; i++) {	942✔
93	if (target_obj.get_backlink(*origin_table, link_col_key, i) == origin_key)	942✔
94	return;	888✔
95	}	942✔
96	REALM_ASSERT(false);	444✔
97	};	×
98		552✔
99	// Verify that forward link has a corresponding backlink	552✔
100	for (size_t i = 0; i < size(); ++i) {	11,688✔
101	if (ObjKey target_key = get(i)) {	10,584✔
102	ObjKey origin_key = cluster->get_real_key(i);	888✔
103		444✔
104	auto target_obj = target_key.is_unresolved() ? target_table->try_get_tombstone(target_key)	459✔
105	: target_table->try_get_object(target_key);	873✔
106	REALM_ASSERT(target_obj);	888✔
107	verify_link(target_obj, origin_key);	888✔
108	}	888✔
109	}	10,584✔
110	#endif	1,104✔
111	}	1,104✔
112
113	} // namespace realm

realm / realm-core / 1713

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