/src/mozilla-central/modules/libpref/test/gtest/CallbackAndVarCacheOrder.cpp

Source (jump to first uncovered line)
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// Test that var caches are updated before callbacks.

#include "gtest/gtest.h"
#include "Preferences.h"

namespace mozilla {

template<typename T, typename U>
struct Closure
{
  U* mLocation;
  T mExpected;
  bool mCalled;
};

template<typename T, typename U>
void
VarChanged(const char* aPrefName, Closure<T, U>* aClosure)
{
  ASSERT_EQ(*aClosure->mLocation, aClosure->mExpected);
  ASSERT_FALSE(aClosure->mCalled);
  aClosure->mCalled = true;
}

void
SetFunc(const nsCString& aPrefName, bool aValue)
{
  nsresult rv = Preferences::SetBool(aPrefName.get(), aValue);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

void
SetFunc(const nsCString& aPrefName, int32_t aValue)
{
  nsresult rv = Preferences::SetInt(aPrefName.get(), aValue);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

void
SetFunc(const nsCString& aPrefName, uint32_t aValue)
{
  nsresult rv = Preferences::SetUint(aPrefName.get(), aValue);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

void
SetFunc(const nsCString& aPrefName, float aValue)
{
  nsresult rv = Preferences::SetFloat(aPrefName.get(), aValue);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

void
AddVarCacheFunc(bool* aVar, const nsCString& aPrefName)
{
  nsresult rv = Preferences::AddBoolVarCache(aVar, aPrefName);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

void
AddVarCacheFunc(Atomic<bool, Relaxed>* aVar, const nsCString& aPrefName)
{
  nsresult rv = Preferences::AddAtomicBoolVarCache(aVar, aPrefName);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

void
AddVarCacheFunc(Atomic<bool, ReleaseAcquire>* aVar, const nsCString& aPrefName)
{
  nsresult rv = Preferences::AddAtomicBoolVarCache(aVar, aPrefName);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

void
AddVarCacheFunc(int32_t* aVar, const nsCString& aPrefName)
{
  nsresult rv = Preferences::AddIntVarCache(aVar, aPrefName);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

void
AddVarCacheFunc(Atomic<int32_t, Relaxed>* aVar, const nsCString& aPrefName)
{
  nsresult rv = Preferences::AddAtomicIntVarCache(aVar, aPrefName);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

void
AddVarCacheFunc(uint32_t* aVar, const nsCString& aPrefName)
{
  nsresult rv = Preferences::AddUintVarCache(aVar, aPrefName);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

void
AddVarCacheFunc(Atomic<uint32_t, Relaxed>* aVar, const nsCString& aPrefName)
{
  nsresult rv = Preferences::AddAtomicUintVarCache(aVar, aPrefName);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

void
AddVarCacheFunc(Atomic<uint32_t, ReleaseAcquire>* aVar,
                const nsCString& aPrefName)
{
  nsresult rv = Preferences::AddAtomicUintVarCache(aVar, aPrefName);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

void
AddVarCacheFunc(float* aVar, const nsCString& aPrefName)
{
  nsresult rv = Preferences::AddFloatVarCache(aVar, aPrefName);
  ASSERT_TRUE(NS_SUCCEEDED(rv));
}

template<typename T, typename U = T>
void
RunTest(const nsCString& aPrefName1,
        const nsCString& aPrefName2,
        T aValue1,
        T aValue2)
{
  static U var1, var2;
  static Closure<T, U> closure1, closure2;
  nsresult rv;

  ASSERT_STRNE(aPrefName1.get(), aPrefName2.get());
  ASSERT_NE(aValue1, aValue2);

  // Call Add*VarCache first.

  SetFunc(aPrefName1, aValue1);

  AddVarCacheFunc(&var1, aPrefName1);
  ASSERT_EQ(var1, aValue1);

  closure1 = { &var1, aValue2 };
  rv = Preferences::RegisterCallback(VarChanged<T, U>, aPrefName1, &closure1);
  ASSERT_TRUE(NS_SUCCEEDED(rv));

  ASSERT_FALSE(closure1.mCalled);
  SetFunc(aPrefName1, aValue2);
  ASSERT_EQ(var1, aValue2);
  ASSERT_TRUE(closure1.mCalled);

  // Call RegisterCallback first.

  SetFunc(aPrefName2, aValue1);

  closure2 = { &var2, aValue2 };
  rv = Preferences::RegisterCallback(VarChanged<T, U>, aPrefName2, &closure2);
  ASSERT_TRUE(NS_SUCCEEDED(rv));

  AddVarCacheFunc(&var2, aPrefName2);
  ASSERT_EQ(var2, aValue1);

  ASSERT_FALSE(closure2.mCalled);
  SetFunc(aPrefName2, aValue2);
  ASSERT_EQ(var2, aValue2);
  ASSERT_TRUE(closure2.mCalled);
}

TEST(CallbackAndVarCacheOrder, Bool)
{
  RunTest<bool>(NS_LITERAL_CSTRING("test_pref.bool.1"),
                NS_LITERAL_CSTRING("test_pref.bool.2"),
                false,
                true);
}

TEST(CallbackAndVarCacheOrder, AtomicBoolRelaxed)
{
  RunTest<bool, Atomic<bool, Relaxed>>(
    NS_LITERAL_CSTRING("test_pref.atomic_bool.1"),
    NS_LITERAL_CSTRING("test_pref.atomic_bool.2"),
    false,
    true);
}

TEST(CallbackAndVarCacheOrder, AtomicBoolReleaseAcquire)
{
  RunTest<bool, Atomic<bool, ReleaseAcquire>>(
    NS_LITERAL_CSTRING("test_pref.atomic_bool.3"),
    NS_LITERAL_CSTRING("test_pref.atomic_bool.4"),
    false,
    true);
}

TEST(CallbackAndVarCacheOrder, Int)
{
  RunTest<int32_t>(NS_LITERAL_CSTRING("test_pref.int.1"),
                   NS_LITERAL_CSTRING("test_pref.int.2"),
                   -2,
                   3);
}

TEST(CallbackAndVarCacheOrder, AtomicInt)
{
  RunTest<int32_t, Atomic<int32_t, Relaxed>>(
    NS_LITERAL_CSTRING("test_pref.atomic_int.1"),
    NS_LITERAL_CSTRING("test_pref.atomic_int.2"),
    -3,
    4);
}

TEST(CallbackAndVarCacheOrder, Uint)
{
  RunTest<uint32_t>(NS_LITERAL_CSTRING("test_pref.uint.1"),
                    NS_LITERAL_CSTRING("test_pref.uint.2"),
                    4u,
                    5u);
}

TEST(CallbackAndVarCacheOrder, AtomicUintRelaxed)
{
  RunTest<uint32_t, Atomic<uint32_t, Relaxed>>(
    NS_LITERAL_CSTRING("test_pref.atomic_uint.1"),
    NS_LITERAL_CSTRING("test_pref.atomic_uint.2"),
    6u,
    7u);
}

TEST(CallbackAndVarCacheOrder, AtomicUintReleaseAcquire)
{
  RunTest<uint32_t, Atomic<uint32_t, ReleaseAcquire>>(
    NS_LITERAL_CSTRING("test_pref.atomic_uint.3"),
    NS_LITERAL_CSTRING("test_pref.atomic_uint.4"),
    8u,
    9u);
}

TEST(CallbackAndVarCacheOrder, Float)
{
  RunTest<float>(NS_LITERAL_CSTRING("test_pref.float.1"),
                 NS_LITERAL_CSTRING("test_pref.float.2"),
                 -10.0f,
                 11.0f);
}

} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53

Line	Count	Source (jump to first uncovered line)
1		/* -- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -- */
2		/* vim: set ts=8 sts=2 et sw=2 tw=80: */
3		/* This Source Code Form is subject to the terms of the Mozilla Public
4		* License, v. 2.0. If a copy of the MPL was not distributed with this
5		* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7		// Test that var caches are updated before callbacks.
8
9		#include "gtest/gtest.h"
10		#include "Preferences.h"
11
12		namespace mozilla {
13
14		template<typename T, typename U>
15		struct Closure
16		{
17		U* mLocation;
18		T mExpected;
19		bool mCalled;
20		};
21
22		template<typename T, typename U>
23		void
24		VarChanged(const char* aPrefName, Closure<T, U>* aClosure)
25	0	{
26	0	ASSERT_EQ(*aClosure->mLocation, aClosure->mExpected);
27	0	ASSERT_FALSE(aClosure->mCalled);
28	0	aClosure->mCalled = true;
29	0	} Unexecuted instantiation: void mozilla::VarChanged<bool, bool>(char const, mozilla::Closure<bool, bool>) Unexecuted instantiation: void mozilla::VarChanged<bool, mozilla::Atomic<bool, (mozilla::MemoryOrdering)0, (mozilla::recordreplay::Behavior)1, void> >(char const, mozilla::Closure<bool, mozilla::Atomic<bool, (mozilla::MemoryOrdering)0, (mozilla::recordreplay::Behavior)1, void> >) Unexecuted instantiation: void mozilla::VarChanged<bool, mozilla::Atomic<bool, (mozilla::MemoryOrdering)1, (mozilla::recordreplay::Behavior)1, void> >(char const, mozilla::Closure<bool, mozilla::Atomic<bool, (mozilla::MemoryOrdering)1, (mozilla::recordreplay::Behavior)1, void> >) Unexecuted instantiation: void mozilla::VarChanged<int, int>(char const, mozilla::Closure<int, int>) Unexecuted instantiation: void mozilla::VarChanged<int, mozilla::Atomic<int, (mozilla::MemoryOrdering)0, (mozilla::recordreplay::Behavior)1, void> >(char const, mozilla::Closure<int, mozilla::Atomic<int, (mozilla::MemoryOrdering)0, (mozilla::recordreplay::Behavior)1, void> >) Unexecuted instantiation: void mozilla::VarChanged<unsigned int, unsigned int>(char const, mozilla::Closure<unsigned int, unsigned int>) Unexecuted instantiation: void mozilla::VarChanged<unsigned int, mozilla::Atomic<unsigned int, (mozilla::MemoryOrdering)0, (mozilla::recordreplay::Behavior)1, void> >(char const, mozilla::Closure<unsigned int, mozilla::Atomic<unsigned int, (mozilla::MemoryOrdering)0, (mozilla::recordreplay::Behavior)1, void> >) Unexecuted instantiation: void mozilla::VarChanged<unsigned int, mozilla::Atomic<unsigned int, (mozilla::MemoryOrdering)1, (mozilla::recordreplay::Behavior)1, void> >(char const, mozilla::Closure<unsigned int, mozilla::Atomic<unsigned int, (mozilla::MemoryOrdering)1, (mozilla::recordreplay::Behavior)1, void> >) Unexecuted instantiation: void mozilla::VarChanged<float, float>(char const, mozilla::Closure<float, float>)
30
31		void
32		SetFunc(const nsCString& aPrefName, bool aValue)
33	0	{
34	0	nsresult rv = Preferences::SetBool(aPrefName.get(), aValue);
35	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
36	0	}
37
38		void
39		SetFunc(const nsCString& aPrefName, int32_t aValue)
40	0	{
41	0	nsresult rv = Preferences::SetInt(aPrefName.get(), aValue);
42	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
43	0	}
44
45		void
46		SetFunc(const nsCString& aPrefName, uint32_t aValue)
47	0	{
48	0	nsresult rv = Preferences::SetUint(aPrefName.get(), aValue);
49	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
50	0	}
51
52		void
53		SetFunc(const nsCString& aPrefName, float aValue)
54	0	{
55	0	nsresult rv = Preferences::SetFloat(aPrefName.get(), aValue);
56	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
57	0	}
58
59		void
60		AddVarCacheFunc(bool* aVar, const nsCString& aPrefName)
61	0	{
62	0	nsresult rv = Preferences::AddBoolVarCache(aVar, aPrefName);
63	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
64	0	}
65
66		void
67		AddVarCacheFunc(Atomic<bool, Relaxed>* aVar, const nsCString& aPrefName)
68	0	{
69	0	nsresult rv = Preferences::AddAtomicBoolVarCache(aVar, aPrefName);
70	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
71	0	}
72
73		void
74		AddVarCacheFunc(Atomic<bool, ReleaseAcquire>* aVar, const nsCString& aPrefName)
75	0	{
76	0	nsresult rv = Preferences::AddAtomicBoolVarCache(aVar, aPrefName);
77	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
78	0	}
79
80		void
81		AddVarCacheFunc(int32_t* aVar, const nsCString& aPrefName)
82	0	{
83	0	nsresult rv = Preferences::AddIntVarCache(aVar, aPrefName);
84	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
85	0	}
86
87		void
88		AddVarCacheFunc(Atomic<int32_t, Relaxed>* aVar, const nsCString& aPrefName)
89	0	{
90	0	nsresult rv = Preferences::AddAtomicIntVarCache(aVar, aPrefName);
91	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
92	0	}
93
94		void
95		AddVarCacheFunc(uint32_t* aVar, const nsCString& aPrefName)
96	0	{
97	0	nsresult rv = Preferences::AddUintVarCache(aVar, aPrefName);
98	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
99	0	}
100
101		void
102		AddVarCacheFunc(Atomic<uint32_t, Relaxed>* aVar, const nsCString& aPrefName)
103	0	{
104	0	nsresult rv = Preferences::AddAtomicUintVarCache(aVar, aPrefName);
105	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
106	0	}
107
108		void
109		AddVarCacheFunc(Atomic<uint32_t, ReleaseAcquire>* aVar,
110		const nsCString& aPrefName)
111	0	{
112	0	nsresult rv = Preferences::AddAtomicUintVarCache(aVar, aPrefName);
113	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
114	0	}
115
116		void
117		AddVarCacheFunc(float* aVar, const nsCString& aPrefName)
118	0	{
119	0	nsresult rv = Preferences::AddFloatVarCache(aVar, aPrefName);
120	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
121	0	}
122
123		template<typename T, typename U = T>
124		void
125		RunTest(const nsCString& aPrefName1,
126		const nsCString& aPrefName2,
127		T aValue1,
128		T aValue2)
129	0	{
130	0	static U var1, var2;
131	0	static Closure<T, U> closure1, closure2;
132	0	nsresult rv;
133	0
134	0	ASSERT_STRNE(aPrefName1.get(), aPrefName2.get());
135	0	ASSERT_NE(aValue1, aValue2);
136	0
137	0	// Call Add*VarCache first.
138	0
139	0	SetFunc(aPrefName1, aValue1);
140	0
141	0	AddVarCacheFunc(&var1, aPrefName1);
142	0	ASSERT_EQ(var1, aValue1);
143	0
144	0	closure1 = { &var1, aValue2 };
145	0	rv = Preferences::RegisterCallback(VarChanged<T, U>, aPrefName1, &closure1);
146	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
147	0
148	0	ASSERT_FALSE(closure1.mCalled);
149	0	SetFunc(aPrefName1, aValue2);
150	0	ASSERT_EQ(var1, aValue2);
151	0	ASSERT_TRUE(closure1.mCalled);
152	0
153	0	// Call RegisterCallback first.
154	0
155	0	SetFunc(aPrefName2, aValue1);
156	0
157	0	closure2 = { &var2, aValue2 };
158	0	rv = Preferences::RegisterCallback(VarChanged<T, U>, aPrefName2, &closure2);
159	0	ASSERT_TRUE(NS_SUCCEEDED(rv));
160	0
161	0	AddVarCacheFunc(&var2, aPrefName2);
162	0	ASSERT_EQ(var2, aValue1);
163	0
164	0	ASSERT_FALSE(closure2.mCalled);
165	0	SetFunc(aPrefName2, aValue2);
166	0	ASSERT_EQ(var2, aValue2);
167	0	ASSERT_TRUE(closure2.mCalled);
168	0	} Unexecuted instantiation: void mozilla::RunTest<bool, bool>(nsTString<char> const&, nsTString<char> const&, bool, bool) Unexecuted instantiation: void mozilla::RunTest<bool, mozilla::Atomic<bool, (mozilla::MemoryOrdering)0, (mozilla::recordreplay::Behavior)1, void> >(nsTString<char> const&, nsTString<char> const&, bool, bool) Unexecuted instantiation: void mozilla::RunTest<bool, mozilla::Atomic<bool, (mozilla::MemoryOrdering)1, (mozilla::recordreplay::Behavior)1, void> >(nsTString<char> const&, nsTString<char> const&, bool, bool) Unexecuted instantiation: void mozilla::RunTest<int, int>(nsTString<char> const&, nsTString<char> const&, int, int) Unexecuted instantiation: void mozilla::RunTest<int, mozilla::Atomic<int, (mozilla::MemoryOrdering)0, (mozilla::recordreplay::Behavior)1, void> >(nsTString<char> const&, nsTString<char> const&, int, int) Unexecuted instantiation: void mozilla::RunTest<unsigned int, unsigned int>(nsTString<char> const&, nsTString<char> const&, unsigned int, unsigned int) Unexecuted instantiation: void mozilla::RunTest<unsigned int, mozilla::Atomic<unsigned int, (mozilla::MemoryOrdering)0, (mozilla::recordreplay::Behavior)1, void> >(nsTString<char> const&, nsTString<char> const&, unsigned int, unsigned int) Unexecuted instantiation: void mozilla::RunTest<unsigned int, mozilla::Atomic<unsigned int, (mozilla::MemoryOrdering)1, (mozilla::recordreplay::Behavior)1, void> >(nsTString<char> const&, nsTString<char> const&, unsigned int, unsigned int) Unexecuted instantiation: void mozilla::RunTest<float, float>(nsTString<char> const&, nsTString<char> const&, float, float)
169
170		TEST(CallbackAndVarCacheOrder, Bool)
171	0	{
172	0	RunTest<bool>(NS_LITERAL_CSTRING("test_pref.bool.1"),
173	0	NS_LITERAL_CSTRING("test_pref.bool.2"),
174	0	false,
175	0	true);
176	0	}
177
178		TEST(CallbackAndVarCacheOrder, AtomicBoolRelaxed)
179	0	{
180	0	RunTest<bool, Atomic<bool, Relaxed>>(
181	0	NS_LITERAL_CSTRING("test_pref.atomic_bool.1"),
182	0	NS_LITERAL_CSTRING("test_pref.atomic_bool.2"),
183	0	false,
184	0	true);
185	0	}
186
187		TEST(CallbackAndVarCacheOrder, AtomicBoolReleaseAcquire)
188	0	{
189	0	RunTest<bool, Atomic<bool, ReleaseAcquire>>(
190	0	NS_LITERAL_CSTRING("test_pref.atomic_bool.3"),
191	0	NS_LITERAL_CSTRING("test_pref.atomic_bool.4"),
192	0	false,
193	0	true);
194	0	}
195
196		TEST(CallbackAndVarCacheOrder, Int)
197	0	{
198	0	RunTest<int32_t>(NS_LITERAL_CSTRING("test_pref.int.1"),
199	0	NS_LITERAL_CSTRING("test_pref.int.2"),
200	0	-2,
201	0	3);
202	0	}
203
204		TEST(CallbackAndVarCacheOrder, AtomicInt)
205	0	{
206	0	RunTest<int32_t, Atomic<int32_t, Relaxed>>(
207	0	NS_LITERAL_CSTRING("test_pref.atomic_int.1"),
208	0	NS_LITERAL_CSTRING("test_pref.atomic_int.2"),
209	0	-3,
210	0	4);
211	0	}
212
213		TEST(CallbackAndVarCacheOrder, Uint)
214	0	{
215	0	RunTest<uint32_t>(NS_LITERAL_CSTRING("test_pref.uint.1"),
216	0	NS_LITERAL_CSTRING("test_pref.uint.2"),
217	0	4u,
218	0	5u);
219	0	}
220
221		TEST(CallbackAndVarCacheOrder, AtomicUintRelaxed)
222	0	{
223	0	RunTest<uint32_t, Atomic<uint32_t, Relaxed>>(
224	0	NS_LITERAL_CSTRING("test_pref.atomic_uint.1"),
225	0	NS_LITERAL_CSTRING("test_pref.atomic_uint.2"),
226	0	6u,
227	0	7u);
228	0	}
229
230		TEST(CallbackAndVarCacheOrder, AtomicUintReleaseAcquire)
231	0	{
232	0	RunTest<uint32_t, Atomic<uint32_t, ReleaseAcquire>>(
233	0	NS_LITERAL_CSTRING("test_pref.atomic_uint.3"),
234	0	NS_LITERAL_CSTRING("test_pref.atomic_uint.4"),
235	0	8u,
236	0	9u);
237	0	}
238
239		TEST(CallbackAndVarCacheOrder, Float)
240	0	{
241	0	RunTest<float>(NS_LITERAL_CSTRING("test_pref.float.1"),
242	0	NS_LITERAL_CSTRING("test_pref.float.2"),
243	0	-10.0f,
244	0	11.0f);
245	0	}
246
247		} // namespace mozilla