Adding upstream version 7.0.6-dfsg.upstream/7.0.6-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 318 insertions, 0 deletions

diff --git a/src/libs/xpcom18a4/nsprpub/pr/tests/bigfile.c b/src/libs/xpcom18a4/nsprpub/pr/tests/bigfile.c
new file mode 100644
index 00000000..19c0a7f9
--- /dev/null
+++ b/src/libs/xpcom18a4/nsprpub/pr/tests/bigfile.c
@@ -0,0 +1,318 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is the Netscape Portable Runtime (NSPR).
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1998-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#include "prio.h"
+#include "prmem.h"
+#include "prprf.h"
+#include "prinit.h"
+#include "prerror.h"
+#include "prthread.h"
+
+#include "plerror.h"
+#include "plgetopt.h"
+
+#define DEFAULT_COUNT 10
+#define DEFAULT_FILESIZE 1
+#define BUFFER_SIZE 1000000
+
+typedef enum {v_silent, v_whisper, v_shout} Verbosity;
+static void Verbose(Verbosity, const char*, const char*, PRIntn);
+
+#define VERBOSE(_l, _m) Verbose(_l, _m, __FILE__, __LINE__)
+
+static PRIntn test_result = 2;
+static PRFileDesc *output = NULL;
+static PRIntn verbose = v_silent;
+static PRIntn filesize = DEFAULT_FILESIZE;
+
+static PRIntn Usage(void)
+{
+    PR_fprintf(output, "Bigfile test usage:\n");
+    PR_fprintf(output, ">bigfile [-G] [-d] [-v[*v]] [-s <n>] <filename>\n");
+    PR_fprintf(output, "\td\tdebug mode (equivalent to -vvv)\t(false)\n");
+    PR_fprintf(output, "\tv\tAdditional levels of output\t(none)\n");
+    PR_fprintf(output, "\tk\tKeep data file after exit\t(false)\n");
+    PR_fprintf(output, "\ts <n>\tFile size in megabytes\t\t(1 megabyte)\n");
+    PR_fprintf(output, "\t<filename>\tName of test file\t(none)\n");
+    return 2;  /* nothing happened */
+}  /* Usage */
+
+static PRStatus DeleteIfFound(const char *filename)
+{
+    PRStatus rv;
+    VERBOSE(v_shout, "Checking for existing file");
+    rv = PR_Access(filename, PR_ACCESS_WRITE_OK);
+    if (PR_SUCCESS == rv)
+    {
+        VERBOSE(v_shout, "Deleting existing file");
+        rv = PR_Delete(filename);
+        if (PR_FAILURE == rv) VERBOSE(v_shout, "Cannot delete big file");
+    }
+    else if (PR_FILE_NOT_FOUND_ERROR !=  PR_GetError())
+        VERBOSE(v_shout, "Cannot access big file");
+    else rv = PR_SUCCESS;
+    return rv;
+}  /* DeleteIfFound */
+
+static PRIntn Error(const char *msg, const char *filename)
+{
+    PRInt32 error = PR_GetError();
+    if (NULL != msg)
+    {
+        if (0 == error) PR_fprintf(output, msg);
+        else PL_FPrintError(output, msg);
+    }
+    (void)DeleteIfFound(filename);
+    if (v_shout == verbose) PR_Abort();
+    return 1;
+}  /* Error */
+
+static void Verbose(
+    Verbosity level, const char *msg, const char *file, PRIntn line)
+{
+    if (level <= verbose)
+        PR_fprintf(output, "[%s : %d]: %s\n", file, line, msg);
+}  /* Verbose */
+
+static void PrintInfo(PRFileInfo64 *info, const char *filename)
+{
+    PRExplodedTime tm;
+    char ctime[40], mtime[40];
+    static const char *types[] = {"FILE", "DIRECTORY", "OTHER"};
+    PR_fprintf(
+        output, "[%s : %d]: File info for %s\n",
+        __FILE__, __LINE__, filename);
+    PR_fprintf(
+        output, "    type: %s, size: %llu bytes,\n",
+        types[info->type - 1], info->size);
+
+    PR_ExplodeTime(info->creationTime, PR_GMTParameters, &tm);
+    (void)PR_FormatTime(ctime, sizeof(ctime), "%c GMT", &tm);
+    PR_ExplodeTime(info->modifyTime, PR_GMTParameters, &tm);
+    (void)PR_FormatTime(mtime, sizeof(mtime), "%c GMT", &tm);
+
+    PR_fprintf(
+        output, "    creation: %s,\n    modify: %s\n", ctime, mtime);
+}  /* PrintInfo */
+
+PRIntn main(PRIntn argc, char **argv)
+{
+    PRStatus rv;
+    char *buffer;
+    PLOptStatus os;
+    PRInt32 loop, bytes;
+    PRFileInfo small_info;
+    PRFileInfo64 big_info;
+    PRBool keep = PR_FALSE;
+    PRFileDesc *file = NULL;
+    const char *filename = NULL;
+    PRIntn count = DEFAULT_COUNT;
+    PRInt64 filesize64, big_answer, big_size, one_meg, zero_meg, big_fragment;
+    PRInt64 sevenFox = LL_INIT(0,0x7fffffff);
+
+    PLOptState *opt = PL_CreateOptState(argc, argv, "dtvhs:");
+
+    output = PR_GetSpecialFD(PR_StandardError);
+    PR_STDIO_INIT();
+
+    while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
+    {
+        if (PL_OPT_BAD == os) continue;
+        switch (opt->option)
+        {
+        case 0:
+            filename = opt->value;
+            break;
+        case 'd':  /* debug mode */
+            verbose = v_shout;
+            break;
+        case 'k':  /* keep file */
+            keep = PR_TRUE;
+            break;
+        case 'v':  /* verbosity */
+            if (v_shout > verbose) verbose += 1;
+            break;
+        case 'c':  /* loop counter */
+            count = atoi(opt->value);
+            break;
+        case 's':  /* filesize */
+            filesize = atoi(opt->value);
+            break;
+        case 'h':  /* confused */
+        default:
+            return Usage();
+        }
+    }
+    PL_DestroyOptState(opt);
+
+    if (0 == count) count = DEFAULT_COUNT;
+    if (0 == filesize) filesize = DEFAULT_FILESIZE;
+    if (NULL == filename)
+    {
+        if (DEFAULT_FILESIZE != filesize) return Usage();
+        else filename = "bigfile.dat";
+    }
+
+    if (PR_FAILURE == DeleteIfFound(filename)) return 1;
+
+    test_result = 0;
+
+    LL_I2L(zero_meg, 0);
+    LL_I2L(one_meg, 1000000);
+    LL_I2L(filesize64, filesize);
+    buffer = (char*)PR_MALLOC(BUFFER_SIZE);
+    LL_I2L(big_fragment, BUFFER_SIZE);
+    LL_MUL(filesize64, filesize64, one_meg); 
+
+    for (loop = 0; loop < BUFFER_SIZE; ++loop) buffer[loop] = (char)loop;
+
+    VERBOSE(v_whisper, "Creating big file");
+    file = PR_Open(filename, PR_CREATE_FILE | PR_WRONLY, 0666);
+    if (NULL == file) return Error("PR_Open()", filename);
+    
+    VERBOSE(v_whisper, "Testing available space in empty file");
+    big_answer = file->methods->available64(file);
+    if (!LL_IS_ZERO(big_answer)) return Error("empty available64()", filename);
+
+	LL_SUB(big_size, filesize64, one_meg);
+    VERBOSE(v_whisper, "Creating sparse big file by seeking to end");
+	big_answer = file->methods->seek64(file, big_size, PR_SEEK_SET);
+    if (!LL_EQ(big_answer, big_size)) return Error("seek", filename);
+
+    VERBOSE(v_whisper, "Writing block at end of sparse file");
+	bytes = file->methods->write(file, buffer, BUFFER_SIZE);
+    if (bytes != BUFFER_SIZE) return Error("write", filename);
+
+    VERBOSE(v_whisper, "Testing available space at end of sparse file");
+    big_answer = file->methods->available64(file);
+    if (!LL_IS_ZERO(big_answer)) return Error("eof available64()", filename);
+
+    VERBOSE(v_whisper, "Getting big info on sparse big file");
+    rv = file->methods->fileInfo64(file, &big_info);
+    if (PR_FAILURE == rv) return Error("fileInfo64()", filename);
+    if (v_shout <= verbose) PrintInfo(&big_info, filename);
+
+    VERBOSE(v_whisper, "Getting small info on sparse big file");
+    rv = file->methods->fileInfo(file, &small_info);
+    if (LL_CMP(sevenFox, <, filesize64) && (PR_SUCCESS == rv))
+    {
+        VERBOSE(v_whisper, "Should have failed and didn't");
+        return Error("fileInfo()", filename);
+    }
+    else if (LL_CMP(sevenFox, >, filesize64) && (PR_FAILURE == rv))
+    {
+        VERBOSE(v_whisper, "Should have succeeded and didn't");
+        return Error("fileInfo()", filename);
+    }
+
+    VERBOSE(v_whisper, "Rewinding big file");
+    big_answer = file->methods->seek64(file, zero_meg, PR_SEEK_SET);
+    if (!LL_IS_ZERO(big_answer)) return Error("rewind seek64()", filename);
+
+    VERBOSE(v_whisper, "Establishing available space in rewound file");
+    big_answer = file->methods->available64(file);
+    if (LL_NE(filesize64, big_answer))
+        return Error("bof available64()", filename);
+
+    VERBOSE(v_whisper, "Closing big file");
+    rv = file->methods->close(file);
+    if (PR_FAILURE == rv) return Error("close()", filename);
+
+    VERBOSE(v_whisper, "Reopening big file");
+    file = PR_Open(filename, PR_RDWR, 0666);
+    if (NULL == file) return Error("open failed", filename);
+
+    VERBOSE(v_whisper, "Checking available data in reopened file");
+    big_answer = file->methods->available64(file);
+    if (LL_NE(filesize64, big_answer))
+        return Error("reopened available64()", filename);
+
+    big_answer = zero_meg;
+    VERBOSE(v_whisper, "Rewriting every byte of big file data");
+    do
+    {
+        bytes = file->methods->write(file, buffer, BUFFER_SIZE);
+        if (bytes != BUFFER_SIZE)
+            return Error("write", filename);
+        LL_ADD(big_answer, big_answer, big_fragment);
+    } while (LL_CMP(big_answer, <, filesize64));
+
+    VERBOSE(v_whisper, "Checking position at eof");
+    big_answer = file->methods->seek64(file, zero_meg, PR_SEEK_CUR);
+    if (LL_NE(big_answer, filesize64))
+        return Error("file size error", filename);
+
+    VERBOSE(v_whisper, "Testing available space at eof");
+    big_answer = file->methods->available64(file);
+    if (!LL_IS_ZERO(big_answer))
+        return Error("eof available64()", filename);
+
+    VERBOSE(v_whisper, "Rewinding full file");
+    big_answer = file->methods->seek64(file, zero_meg, PR_SEEK_SET);
+    if (!LL_IS_ZERO(big_answer)) return Error("bof seek64()", filename);
+
+    VERBOSE(v_whisper, "Testing available space in rewound file");
+    big_answer = file->methods->available64(file);
+    if (LL_NE(big_answer, filesize64)) return Error("bof available64()", filename);
+
+    VERBOSE(v_whisper, "Seeking to end of big file");
+    big_answer = file->methods->seek64(file, filesize64, PR_SEEK_SET);
+    if (LL_NE(big_answer, filesize64)) return Error("eof seek64()", filename);
+
+    VERBOSE(v_whisper, "Getting info on big file while it's open");
+    rv = file->methods->fileInfo64(file, &big_info);
+    if (PR_FAILURE == rv) return Error("fileInfo64()", filename);
+    if (v_shout <= verbose) PrintInfo(&big_info, filename);
+
+    VERBOSE(v_whisper, "Closing big file");
+    rv = file->methods->close(file);
+    if (PR_FAILURE == rv) return Error("close()", filename);
+
+    VERBOSE(v_whisper, "Getting info on big file after it's closed");
+    rv = PR_GetFileInfo64(filename, &big_info);
+    if (PR_FAILURE == rv) return Error("fileInfo64()", filename);
+    if (v_shout <= verbose) PrintInfo(&big_info, filename);
+
+    VERBOSE(v_whisper, "Deleting big file");
+    rv = PR_Delete(filename);
+    if (PR_FAILURE == rv) return Error("PR_Delete()", filename);
+
+    PR_DELETE(buffer);
+    return test_result;
+} /* main */
+
+/* bigfile.c */