1*51134e9eSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3*51134e9eSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4*51134e9eSAndrew Rist * or more contributor license agreements. See the NOTICE file
5*51134e9eSAndrew Rist * distributed with this work for additional information
6*51134e9eSAndrew Rist * regarding copyright ownership. The ASF licenses this file
7*51134e9eSAndrew Rist * to you under the Apache License, Version 2.0 (the
8*51134e9eSAndrew Rist * "License"); you may not use this file except in compliance
9*51134e9eSAndrew Rist * with the License. You may obtain a copy of the License at
10*51134e9eSAndrew Rist *
11*51134e9eSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12*51134e9eSAndrew Rist *
13*51134e9eSAndrew Rist * Unless required by applicable law or agreed to in writing,
14*51134e9eSAndrew Rist * software distributed under the License is distributed on an
15*51134e9eSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*51134e9eSAndrew Rist * KIND, either express or implied. See the License for the
17*51134e9eSAndrew Rist * specific language governing permissions and limitations
18*51134e9eSAndrew Rist * under the License.
19*51134e9eSAndrew Rist *
20*51134e9eSAndrew Rist *************************************************************/
21*51134e9eSAndrew Rist
22*51134e9eSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_registry.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir #include <iostream>
28cdf0e10cSrcweir #include <stdio.h>
29cdf0e10cSrcweir #include <stdlib.h>
30cdf0e10cSrcweir #include <time.h>
31cdf0e10cSrcweir #include <sys/timeb.h>
32cdf0e10cSrcweir #include <sys/types.h>
33cdf0e10cSrcweir
34cdf0e10cSrcweir #include "registry/registry.h"
35cdf0e10cSrcweir #include <rtl/ustring.hxx>
36cdf0e10cSrcweir #include <rtl/alloc.h>
37cdf0e10cSrcweir
38cdf0e10cSrcweir using namespace std;
39cdf0e10cSrcweir
40cdf0e10cSrcweir /*****************************************************************
41cdf0e10cSrcweir MyTimer
42cdf0e10cSrcweir *****************************************************************/
43cdf0e10cSrcweir #ifndef UNX
44cdf0e10cSrcweir class MyTimer
45cdf0e10cSrcweir {
46cdf0e10cSrcweir public:
start()47cdf0e10cSrcweir void start() { _ftime( &m_start ); };
stop()48cdf0e10cSrcweir void stop()
49cdf0e10cSrcweir {
50cdf0e10cSrcweir _ftime( &m_stop );
51cdf0e10cSrcweir m_diff = difftime(m_stop.time, m_start.time);
52cdf0e10cSrcweir if (m_stop.millitm > m_start.millitm)
53cdf0e10cSrcweir {
54cdf0e10cSrcweir m_diff += ((double)(m_stop.millitm - m_start.millitm)) / 1000;
55cdf0e10cSrcweir }
56cdf0e10cSrcweir else
57cdf0e10cSrcweir {
58cdf0e10cSrcweir m_diff -= 1;
59cdf0e10cSrcweir m_diff += ((double)(1000 - (m_start.millitm - m_stop.millitm))) / 1000;
60cdf0e10cSrcweir }
61cdf0e10cSrcweir printf(" %.4f Sekunden\n", m_diff);
62cdf0e10cSrcweir };
63cdf0e10cSrcweir
64cdf0e10cSrcweir protected:
65cdf0e10cSrcweir #ifdef OS2
66cdf0e10cSrcweir struct timeb m_start, m_stop;
67cdf0e10cSrcweir #else
68cdf0e10cSrcweir struct _timeb m_start, m_stop;
69cdf0e10cSrcweir #endif
70cdf0e10cSrcweir double m_diff;
71cdf0e10cSrcweir };
72cdf0e10cSrcweir #else
73cdf0e10cSrcweir extern "C" int ftime(struct timeb *pt);
74cdf0e10cSrcweir
75cdf0e10cSrcweir class MyTimer
76cdf0e10cSrcweir {
77cdf0e10cSrcweir public:
start()78cdf0e10cSrcweir void start() { ftime( &m_start ); };
stop()79cdf0e10cSrcweir void stop()
80cdf0e10cSrcweir {
81cdf0e10cSrcweir ftime( &m_stop );
82cdf0e10cSrcweir m_diff = difftime(m_stop.time, m_start.time);
83cdf0e10cSrcweir if (m_stop.millitm > m_start.millitm)
84cdf0e10cSrcweir {
85cdf0e10cSrcweir m_diff += ((double)(m_stop.millitm - m_start.millitm)) / 1000;
86cdf0e10cSrcweir }
87cdf0e10cSrcweir else
88cdf0e10cSrcweir {
89cdf0e10cSrcweir m_diff -= 1;
90cdf0e10cSrcweir m_diff += ((double)(1000 - (m_start.millitm - m_stop.millitm))) / 1000;
91cdf0e10cSrcweir }
92cdf0e10cSrcweir printf(" %.4f Sekunden\n", m_diff);
93cdf0e10cSrcweir };
94cdf0e10cSrcweir
95cdf0e10cSrcweir protected:
96cdf0e10cSrcweir struct timeb m_start, m_stop;
97cdf0e10cSrcweir double m_diff;
98cdf0e10cSrcweir };
99cdf0e10cSrcweir #endif
100cdf0e10cSrcweir
101cdf0e10cSrcweir using namespace rtl;
102cdf0e10cSrcweir
103cdf0e10cSrcweir #if (defined UNX) || (defined OS2)
main(int argc,char * argv[])104cdf0e10cSrcweir int main( int argc, char * argv[] )
105cdf0e10cSrcweir #else
106cdf0e10cSrcweir int _cdecl main( int argc, char * argv[] )
107cdf0e10cSrcweir #endif
108cdf0e10cSrcweir {
109cdf0e10cSrcweir RegHandle hReg;
110cdf0e10cSrcweir RegKeyHandle hRootKey, hKey, hSubKey, hSubSubKey;
111cdf0e10cSrcweir OUString sName1(RTL_CONSTASCII_USTRINGPARAM("regkey"));
112cdf0e10cSrcweir OUString sName2(RTL_CONSTASCII_USTRINGPARAM("regSubkey"));
113cdf0e10cSrcweir OUString sName3(RTL_CONSTASCII_USTRINGPARAM("regSubSubkey"));
114cdf0e10cSrcweir OUString keyName1;
115cdf0e10cSrcweir OUString keyName2;
116cdf0e10cSrcweir OUString keyName3;
117cdf0e10cSrcweir int S1 = 10;
118cdf0e10cSrcweir int S2 = 10;
119cdf0e10cSrcweir int S3 = 10;
120cdf0e10cSrcweir MyTimer aTimer;
121cdf0e10cSrcweir
122cdf0e10cSrcweir if (argc < 4)
123cdf0e10cSrcweir {
124cdf0e10cSrcweir cerr << "using regspeed count1 count2 count3\n";
125cdf0e10cSrcweir exit(1);
126cdf0e10cSrcweir }
127cdf0e10cSrcweir
128cdf0e10cSrcweir S1 = atoi(argv[1]);
129cdf0e10cSrcweir S2 = atoi(argv[2]);
130cdf0e10cSrcweir S3 = atoi(argv[3]);
131cdf0e10cSrcweir
132cdf0e10cSrcweir OUString speedReg( RTL_CONSTASCII_USTRINGPARAM("speed.reg"));
133cdf0e10cSrcweir if (reg_createRegistry(speedReg.pData, &hReg))
134cdf0e10cSrcweir {
135cdf0e10cSrcweir cout << "creating registry \"test.reg\" failed\n";
136cdf0e10cSrcweir } else
137cdf0e10cSrcweir {
138cdf0e10cSrcweir if (reg_openRootKey(hReg, &hRootKey))
139cdf0e10cSrcweir {
140cdf0e10cSrcweir cout << "open root key \"test.reg\" failed\n";
141cdf0e10cSrcweir } else
142cdf0e10cSrcweir {
143cdf0e10cSrcweir printf("\n %d keys anlegen, oeffnen und schliessen dauert ... ", (S1 * S2 * S3));
144cdf0e10cSrcweir aTimer.start();
145cdf0e10cSrcweir
146cdf0e10cSrcweir for (sal_Int32 i=0; i < S1; i++)
147cdf0e10cSrcweir {
148cdf0e10cSrcweir keyName1 = sName1;
149cdf0e10cSrcweir keyName1 += OUString().valueOf(i);
150cdf0e10cSrcweir if (reg_createKey(hRootKey, keyName1.pData, &hKey))
151cdf0e10cSrcweir cout << "creating key \"" << OUStringToOString(keyName1, RTL_TEXTENCODING_ASCII_US).getStr()
152cdf0e10cSrcweir << "\" failed\n";
153cdf0e10cSrcweir
154cdf0e10cSrcweir for (sal_Int32 j=0; j < S2; j++)
155cdf0e10cSrcweir {
156cdf0e10cSrcweir keyName2 = sName2;
157cdf0e10cSrcweir keyName2 += OUString().valueOf(j);
158cdf0e10cSrcweir if (reg_createKey(hKey, keyName2.pData, &hSubKey))
159cdf0e10cSrcweir cout << "creating key \"" << OUStringToOString(keyName2, RTL_TEXTENCODING_ASCII_US).getStr()
160cdf0e10cSrcweir << "\" failed\n";
161cdf0e10cSrcweir
162cdf0e10cSrcweir for (sal_Int32 n=0; n < S3; n++)
163cdf0e10cSrcweir {
164cdf0e10cSrcweir keyName3 = sName3;
165cdf0e10cSrcweir keyName3 += OUString().valueOf(n);
166cdf0e10cSrcweir if (reg_createKey(hSubKey, keyName3.pData, &hSubSubKey))
167cdf0e10cSrcweir cout << "creating key \"" << OUStringToOString(keyName3, RTL_TEXTENCODING_ASCII_US).getStr()
168cdf0e10cSrcweir << "\" failed\n";
169cdf0e10cSrcweir
170cdf0e10cSrcweir if (reg_closeKey(hSubSubKey))
171cdf0e10cSrcweir cout << "closing key \"" << OUStringToOString(keyName3, RTL_TEXTENCODING_ASCII_US).getStr()
172cdf0e10cSrcweir << "\" failed\n";
173cdf0e10cSrcweir }
174cdf0e10cSrcweir
175cdf0e10cSrcweir if (reg_closeKey(hSubKey))
176cdf0e10cSrcweir cout << "closing key \"" << OUStringToOString(keyName2, RTL_TEXTENCODING_ASCII_US).getStr()
177cdf0e10cSrcweir << "\" failed\n";
178cdf0e10cSrcweir }
179cdf0e10cSrcweir
180cdf0e10cSrcweir if (reg_closeKey(hKey))
181cdf0e10cSrcweir cout << "closing key \"" << OUStringToOString(keyName1, RTL_TEXTENCODING_ASCII_US).getStr()
182cdf0e10cSrcweir << "\" failed\n";
183cdf0e10cSrcweir }
184cdf0e10cSrcweir
185cdf0e10cSrcweir aTimer.stop();
186cdf0e10cSrcweir
187cdf0e10cSrcweir printf("\n %d keys oeffnen und schliessen dauert ... ", (S1 * S2 * S3));
188cdf0e10cSrcweir aTimer.start();
189cdf0e10cSrcweir
190cdf0e10cSrcweir for (sal_Int32 i=0; i < S1; i++)
191cdf0e10cSrcweir {
192cdf0e10cSrcweir keyName1 = OUString::createFromAscii("/");
193cdf0e10cSrcweir keyName1 += sName1;
194cdf0e10cSrcweir keyName1 += OUString().valueOf(i);
195cdf0e10cSrcweir if (reg_openKey(hRootKey, keyName1.pData, &hKey))
196cdf0e10cSrcweir cout << "open key \"" << OUStringToOString(keyName1, RTL_TEXTENCODING_ASCII_US).getStr()
197cdf0e10cSrcweir << "\" failed\n";
198cdf0e10cSrcweir
199cdf0e10cSrcweir for (sal_Int32 j=0; j < S2; j++)
200cdf0e10cSrcweir {
201cdf0e10cSrcweir keyName2 = OUString::createFromAscii("/");
202cdf0e10cSrcweir keyName2 += sName1;
203cdf0e10cSrcweir keyName2 += OUString().valueOf(i);
204cdf0e10cSrcweir keyName2 += OUString::createFromAscii("/");
205cdf0e10cSrcweir keyName2 += sName2;
206cdf0e10cSrcweir keyName2 += OUString().valueOf(j);
207cdf0e10cSrcweir if (reg_openKey(hRootKey, keyName2.pData, &hSubKey))
208cdf0e10cSrcweir cout << "open key \"" << OUStringToOString(keyName2, RTL_TEXTENCODING_ASCII_US).getStr()
209cdf0e10cSrcweir << "\" failed\n";
210cdf0e10cSrcweir
211cdf0e10cSrcweir for (sal_Int32 n=0; n < S3; n++)
212cdf0e10cSrcweir {
213cdf0e10cSrcweir keyName3 = OUString::createFromAscii("/");
214cdf0e10cSrcweir keyName3 += sName1;
215cdf0e10cSrcweir keyName3 += OUString().valueOf(i);
216cdf0e10cSrcweir keyName3 += OUString::createFromAscii("/");
217cdf0e10cSrcweir keyName3 += sName2;
218cdf0e10cSrcweir keyName3 += OUString().valueOf(j);
219cdf0e10cSrcweir keyName3 += OUString::createFromAscii("/");
220cdf0e10cSrcweir keyName3 += sName3;
221cdf0e10cSrcweir keyName3 += OUString().valueOf(n);
222cdf0e10cSrcweir if (reg_openKey(hRootKey, keyName3.pData, &hSubSubKey))
223cdf0e10cSrcweir cout << "open key \"" << OUStringToOString(keyName3, RTL_TEXTENCODING_ASCII_US).getStr()
224cdf0e10cSrcweir << "\" failed\n";
225cdf0e10cSrcweir
226cdf0e10cSrcweir if (reg_closeKey(hSubSubKey))
227cdf0e10cSrcweir cout << "open key \"" << OUStringToOString(keyName3, RTL_TEXTENCODING_ASCII_US).getStr()
228cdf0e10cSrcweir << "\" failed\n";
229cdf0e10cSrcweir }
230cdf0e10cSrcweir
231cdf0e10cSrcweir if (reg_closeKey(hSubKey))
232cdf0e10cSrcweir cout << "closing key \"" << OUStringToOString(keyName2, RTL_TEXTENCODING_ASCII_US).getStr()
233cdf0e10cSrcweir << "\" failed\n";
234cdf0e10cSrcweir }
235cdf0e10cSrcweir
236cdf0e10cSrcweir if (reg_closeKey(hKey))
237cdf0e10cSrcweir cout << "closing key \"" << OUStringToOString(keyName1, RTL_TEXTENCODING_ASCII_US).getStr()
238cdf0e10cSrcweir << "\" failed\n";
239cdf0e10cSrcweir }
240cdf0e10cSrcweir
241cdf0e10cSrcweir aTimer.stop();
242cdf0e10cSrcweir
243cdf0e10cSrcweir printf("\n 1 key oeffnen und schliessen dauert ... ");
244cdf0e10cSrcweir aTimer.start();
245cdf0e10cSrcweir
246cdf0e10cSrcweir if (reg_openKey(hRootKey, keyName3.pData, &hSubSubKey))
247cdf0e10cSrcweir cout << "open key \"" << OUStringToOString(keyName3, RTL_TEXTENCODING_ASCII_US).getStr()
248cdf0e10cSrcweir << "\" failed\n";
249cdf0e10cSrcweir
250cdf0e10cSrcweir if (reg_closeKey(hSubSubKey))
251cdf0e10cSrcweir cout << "open key \"" << OUStringToOString(keyName3, RTL_TEXTENCODING_ASCII_US).getStr()
252cdf0e10cSrcweir << "\" failed\n";
253cdf0e10cSrcweir
254cdf0e10cSrcweir aTimer.stop();
255cdf0e10cSrcweir
256cdf0e10cSrcweir }
257cdf0e10cSrcweir
258cdf0e10cSrcweir if (reg_closeKey(hRootKey))
259cdf0e10cSrcweir cout << "closing root key failed\n";
260cdf0e10cSrcweir if (reg_closeRegistry(hReg))
261cdf0e10cSrcweir cout << "\t41. closing registry \"test.reg\" failed\n";
262cdf0e10cSrcweir }
263cdf0e10cSrcweir
264cdf0e10cSrcweir return(0);
265cdf0e10cSrcweir }
266cdf0e10cSrcweir
267cdf0e10cSrcweir
268