store/workben/t_file.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: t_file.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_store.hxx"
  33
  34 #include "sal/types.h"
  35 #include "osl/thread.h"
  36 #include "rtl/ustring.hxx"
  37
  38 #include "lockbyte.hxx"
  39
  40 #ifndef INCLUDED_STDIO_H
  41 #include <stdio.h>
  42 #define INCLUDED_STDIO_H
  43 #endif
  44
  45 #include "osl/file.h"
  46 #include "osl/process.h"
  47
  48 using namespace store;
  49
  50 #define TEST_PAGESIZE 16384
  51
  52 /*========================================================================
  53  *
  54  * main.
  55  *
  56  *======================================================================*/
  57 int SAL_CALL main (int argc, char **argv)
  58 {
  59     storeError eErrCode = store_E_None;
  60     rtl::Reference<ILockBytes> xLockBytes;
  61
  62     if (argc > 1)
  63     {
  64         rtl::OUString aFilename (
  65             argv[1], rtl_str_getLength(argv[1]),
  66             osl_getThreadTextEncoding());
  67
  68 #if 0   /* EXP */
  69         oslFileError result;
  70         rtl::OUString aPath;
  71
  72         result = osl_getFileURLFromSystemPath(aFilename.pData, &(aPath.pData));
  73         if (result != osl_File_E_None)
  74         {
  75             // not SystemPath, assume FileUrl.
  76             aPath = aFilename;
  77         }
  78         if (rtl_ustr_ascii_shortenedCompare_WithLength(aPath.pData->buffer, aPath.pData->length, "file://", 7) != 0)
  79         {
  80             // not FileUrl, assume relative path.
  81             rtl::OUString aBase;
  82             (void) osl_getProcessWorkingDir (&(aBase.pData));
  83
  84             // absolute FileUrl.
  85             (void) osl_getAbsoluteFileURL(aBase.pData, aPath.pData, &(aPath.pData));
  86         }
  87         aFilename = aPath;
  88 #endif  /* EXP */
  89
  90         eErrCode = FileLockBytes_createInstance (
  91             xLockBytes, aFilename.pData, store_AccessReadWrite);
  92         if (eErrCode != store_E_None)
  93         {
  94             // Check reason.
  95             if (eErrCode != store_E_NotExists)
  96             {
  97                 fprintf (stderr, "t_file: create() error: %d\n", eErrCode);
  98                 return eErrCode;
  99             }
 100
 101             // Create.
 102             eErrCode = FileLockBytes_createInstance (
 103                 xLockBytes, aFilename.pData, store_AccessReadCreate);
 104             if (eErrCode != store_E_None)
 105             {
 106                 fprintf (stderr, "t_file: create() error: %d\n", eErrCode);
 107                 return eErrCode;
 108             }
 109         }
 110         fprintf (stdout, "t_file: using FileLockBytes(\"%s\") implementation.\n", argv[1]);
 111     }
 112     else
 113     {
 114         eErrCode = MemoryLockBytes_createInstance (xLockBytes);
 115         if (eErrCode != store_E_None)
 116         {
 117             fprintf (stderr, "t_file: create() error: %d\n", eErrCode);
 118             return eErrCode;
 119         }
 120         fprintf (stdout, "t_file: using MemoryLockBytes implementation.\n");
 121     }
 122
 123     rtl::Reference< PageData::Allocator > xAllocator;
 124     eErrCode = xLockBytes->initialize (xAllocator, TEST_PAGESIZE);
 125     if (eErrCode != store_E_None)
 126     {
 127         fprintf (stderr, "t_file: initialize() error: %d\n", eErrCode);
 128         return eErrCode;
 129     }
 130
 131     sal_Char buffer[TEST_PAGESIZE];
 132     rtl_fillMemory (buffer, sizeof(buffer), sal_uInt8('B'));
 133
 134     sal_uInt32 i, k;
 135     for (k = 0; k < 4; k++)
 136     {
 137         sal_uInt32 index = k * TEST_PAGESIZE / 4;
 138         buffer[index] = 'A';
 139     }
 140
 141     for (i = 0; i < 256; i++)
 142     {
 143         sal_uInt32 offset = i * TEST_PAGESIZE;
 144         eErrCode = xLockBytes->setSize (offset + TEST_PAGESIZE);
 145         if (eErrCode != store_E_None)
 146         {
 147             fprintf (stderr, "t_file: setSize() error: %d\n", eErrCode);
 148             return eErrCode;
 149         }
 150
 151         for (k = 0; k < 4; k++)
 152         {
 153             sal_uInt32 magic = i * 4 + k;
 154             if (magic)
 155             {
 156                 sal_uInt32 verify = 0;
 157                 eErrCode = xLockBytes->readAt (
 158                     0, &verify, sizeof(verify));
 159                 if (eErrCode != store_E_None)
 160                 {
 161                     fprintf (stderr, "t_file: readAt() error: %d\n", eErrCode);
 162                     return eErrCode;
 163                 }
 164                 if (verify != magic)
 165                 {
 166                     // Failure.
 167                     fprintf (stderr, "Expected %ld read %ld\n", (unsigned long)(magic), (unsigned long)(verify));
 168                 }
 169             }
 170
 171             sal_uInt32 index = k * TEST_PAGESIZE / 4;
 172             eErrCode = xLockBytes->writeAt (
 173                 offset + index, &(buffer[index]), TEST_PAGESIZE / 4);
 174             if (eErrCode != store_E_None)
 175             {
 176                 fprintf (stderr, "t_file: writeAt() error: %d\n", eErrCode);
 177                 return eErrCode;
 178             }
 179
 180             magic += 1;
 181             eErrCode = xLockBytes->writeAt (
 182                 0, &magic, sizeof(magic));
 183             if (eErrCode != store_E_None)
 184             {
 185                 fprintf (stderr, "t_file: writeAt() error: %d\n", eErrCode);
 186                 return eErrCode;
 187             }
 188         }
 189     }
 190
 191     eErrCode = xLockBytes->flush();
 192     if (eErrCode != store_E_None)
 193     {
 194         fprintf (stderr, "t_file: flush() error: %d\n", eErrCode);
 195         return eErrCode;
 196     }
 197
 198     sal_Char verify[TEST_PAGESIZE];
 199     for (i = 0; i < 256; i++)
 200     {
 201         sal_uInt32 offset = i * TEST_PAGESIZE;
 202
 203         eErrCode = xLockBytes->readAt (offset, verify, TEST_PAGESIZE);
 204         if (eErrCode != store_E_None)
 205         {
 206             fprintf (stderr, "t_file: readAt() error: %d\n", eErrCode);
 207             return eErrCode;
 208         }
 209
 210         sal_uInt32 index = 0;
 211         if (offset == 0)
 212         {
 213             sal_uInt32 magic = 256 * 4;
 214             if (rtl_compareMemory (&verify[index], &magic, sizeof(magic)))
 215             {
 216                 // Failure.
 217                 fprintf (stderr, "t_file: Unexpected value at 0x00000000\n");
 218             }
 219             index += 4;
 220         }
 221         if (rtl_compareMemory (
 222             &verify[index], &buffer[index], TEST_PAGESIZE - index))
 223         {
 224             // Failure.
 225             fprintf (stderr, "t_file: Unexpected block at 0x%08x\n", (unsigned)(offset));
 226         }
 227     }
 228
 229     for (i = 0; i < 256; i++)
 230     {
 231         PageHolder xPage;
 232         sal_uInt32 offset = i * TEST_PAGESIZE;
 233
 234         eErrCode = xLockBytes->readPageAt (xPage, offset);
 235         if (eErrCode != store_E_None)
 236         {
 237             fprintf (stderr, "t_file: readPageAt() error: %d\n", eErrCode);
 238             return eErrCode;
 239         }
 240
 241         PageData * page = xPage.get();
 242         (void)page; // UNUSED
 243     }
 244
 245     xLockBytes.clear();
 246     return 0;
 247 }