English | العربية | বাংলা | Bosanski | Deutsch | Español | Français | हिन्दी | Italiano | 日本語 | 한국어 | मराठी | Português | Русский | Kiswahili | தமிழ் | తెలుగు | Türkçe | اردو | Tiếng Việt | 中文

• Einführung
  • Hauptmerkmale
  • Beispiel
• Installation
  • Anforderungen
  • Optionale Abhängigkeiten
• Verwendung
  • Grundlegender Workflow
  • Speicherkonfiguration
  • Nebenläufigkeitskonfiguration
  • Dateibenennung
  • Saatgut für Reproduzierbarkeit
• Generatoren
  • Bildgeneratoren
  • Textgenerator
  • CSV-Generator
  • Binärgenerator
  • E-Mail-Generator
• Erweiterte Nutzung
  • Benutzerdefinierte Generatoren
  • Konfigurationsklassen
  • Leistungstipps
• Konfiguration
  • Globale Konfigurationsmethoden
• Support Richtlinien
  • Community-gesteuerte Unterstützung
  • Bugs und Priorisierung von Funktionen
• Lizenz - MIT Lizenz

🔗Einführung

Faker Storage ist ein leistungsstarkes PHP-Paket, das entwickelt wurde, um große Mengen gefälschter Datendateien effizient zu generieren und zu speichern. Mit dem Fokus auf Nebenläufigkeit nutzt es Swoole oder PCNTL, um Tausende von Dateien parallel zu generieren, was es ideal für Lasttests, Entwicklungsumgebungen und Benchmarking von Speichersystemen macht.

Das Paket bietet eine fließende API zur Generierung verschiedener Dateitypen, einschließlich Bilder (PNG, JPG, GIF, BMP, WEBP, AVIF), Textdateien, CSV-Dateien, Binärdaten und RFC822-konformer E-Mails. Jeder Generator produziert deterministische Ausgaben, wenn er mit einem Seed initialisiert wird, wodurch reproduzierbare Testdaten in verschiedenen Umgebungen gewährleistet werden.

🔗Hauptmerkmale

• Hochleistungs-Nebenläufigkeit: Automatische Auswahl zwischen Swoole (Koroutinen) und PCNTL (Prozess-Forking) für die parallele Dateigenerierung
• Mehrere Dateigeneratoren: Eingebaute Unterstützung für Bilder, Text, CSV, Binär- und E-Mail-Dateien
• Deterministische Ausgaben: Seed-basierte Generierung sorgt für reproduzierbare Ergebnisse
• Flexible Speicherung: Funktioniert mit jedem League Flysystem-Adapter (lokal, S3 usw.)
• Anpassbare Dateinamen: Closure-basierte Namensgenerierung mit voller Kontrolle
• Bildunterstützung: Mehrere Formate mit konfigurierbaren Abmessungen und Komprimierung
• E-Mail-Generierung: RFC822-konforme E-Mails mit Anhängen und MIME-Unterstützung

🔗Beispiel

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Png;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// Generieren Sie 1000 PNG-Bilder mit 10 gleichzeitigen Arbeitern
Faker::make(Png::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->basePath('images')
    ->count(1000)
    ->concurrency(10)
    ->seed(42)
    ->generate();
 
// Generieren Sie CSV-Dateien
use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)
    ->rows(100, 500)
    ->delimiter(',')
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->count(50)
    ->generate();
 
// Generieren Sie E-Mails mit Anhängen
use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)
    ->sentences(2, 4)
    ->withAttachment(Png::class, 1, 3)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/path/to/storage')))
    ->count(100)
    ->generate();

🔗Installation

Installieren Sie das Paket über Composer:

composer require defectivecode/faker-storage

🔗Anforderungen

• PHP >= 8.4
• ext-gd (für die Bilderzeugung)
• ext-swoole (optional, für bessere Leistung)
• ext-pcntl (Fallback für Nebenläufigkeit)

🔗Optionale Abhängigkeiten

Für optimale Leistung installieren Sie die Swoole-Erweiterung:

pecl install swoole

Das Paket verwendet automatisch Swoole, wenn verfügbar, und fällt andernfalls auf PCNTL zurück.

🔗Verwendung

🔗Grundlegender Workflow

Alle Generatoren folgen demselben Muster:

1. Erstellen Sie eine Faker-Instanz mit einem Generator
2. Konfigurieren Sie den Generator (optional)
3. Legen Sie das Speicherziel fest
4. Konfigurieren Sie Nebenläufigkeit und Zählung
5. Generieren Sie Dateien

use DefectiveCode\Faker\Faker;
use League\Flysystem\Filesystem;
use DefectiveCode\Faker\Generators\Text;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)          // Generator-spezifische Konfiguration
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))
    ->basePath('documents')      // Dateien werden in /storage/documents/ sein
    ->count(100)                 // 100 Dateien generieren
    ->concurrency(4)             // Verwenden Sie 4 Arbeiter
    ->seed(123)                  // Für deterministische Ausgaben
    ->generate();

🔗Speicherkonfiguration

Verwendung von Flysystem

Faker Storage verwendet League Flysystem für die Speicherabstraktion:

use League\Flysystem\Filesystem;
use League\Flysystem\Local\LocalFilesystemAdapter;
 
// Lokaler Speicher
$filesystem = new Filesystem(new LocalFilesystemAdapter('/path/to/storage'));
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->generate();

AWS S3-Speicher

use Aws\S3\S3Client;
use League\Flysystem\Filesystem;
use League\Flysystem\AwsS3V3\AwsS3V3Adapter;
 
$client = new S3Client([
    'credentials' => [
        'key'    => 'your-key',
        'secret' => 'your-secret',
    ],
    'region' => 'us-east-1',
    'version' => 'latest',
]);
 
$adapter = new AwsS3V3Adapter($client, 'your-bucket-name');
$filesystem = new Filesystem($adapter);
 
Faker::make(Png::class)
    ->toDisk($filesystem)
    ->basePath('uploads/images')
    ->generate();

Festplattenteinstellungen

Übergeben Sie zusätzliche Optionen an den Dateisystemadapter:

Faker::make(Png::class)
    ->toDisk($filesystem)
    ->diskOptions([
        'visibility' => 'public',
        'ACL' => 'public-read',
        'CacheControl' => 'max-age=31536000',
    ])
    ->generate();

🔗Nebenläufigkeitskonfiguration

Steuern Sie die parallele Ausführung mit der Methode concurrency():

// Verwenden Sie 10 Arbeits-Threads/-prozesse
Faker::make(Png::class)
    ->concurrency(10)
    ->generate();
 
// Swoole-spezifisch: Setzen Sie sowohl Threads als auch Koroutinen pro Thread
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)  // 4 Arbeiter, 8 Koroutinen jeweils
    ->generate();

🔗Dateibenennung

Standardbenennung

Standardmäßig werden Dateien mit UUID v4 benannt:

// Generiert: e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
Faker::make(Png::class)->generate();

Eingebaute Namensgeneratoren

use DefectiveCode\Faker\NameGenerator;
 
// UUID-basiert (Standard)
NameGenerator::setDefault('uuid'); // Generiert: e7f0a8d3-5c2b-4f9e-8a1d-3b4c5d6e7f8a.png
 
// Sequenzielle Nummerierung
NameGenerator::setDefault('sequence'); // Generiert: 1.png, 2.png, 3.png, ...

Benutzerdefinierte Benennung

Geben Sie eine Closure an, um Dateinamen anzupassen:

use DefectiveCode\Faker\NameGenerator;
 
// Benutzerdefinierte Closure
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "custom-{$completedFiles}-{$seed}.png";
    })
    ->generate();
 
// Datum-basierte Benennung
Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return date('Y/m/d') . "/image-{$completedFiles}.png";
    })
    ->generate();

🔗Saatgut für Reproduzierbarkeit

Setzen Sie einen Seed, um die gleichen Dateien über mehrere Durchläufe zu generieren:

Faker::make(Png::class)
    ->seed(42)
    ->count(10)
    ->generate();

Jede Datei erhält einen einzigartigen deterministischen Seed, der aus dem Basis-Seed und dem Dateiindex abgeleitet ist.

🔗Generatoren

🔗Bildgeneratoren

Alle Bildgeneratoren unterstützen Dimensionen und Qualitätskonfigurationen.

PNG

use DefectiveCode\Faker\Generators\Png;
 
Faker::make(Png::class)
    ->width(800, 1920)          // Zufällige Breite zwischen 800-1920px
    ->height(600, 1080)         // Zufällige Höhe zwischen 600-1080px
    ->withAlpha(true)           // Alpha-/Transparenzkanal aktivieren
    ->grid(5)                   // Optional: Generieren Sie ein 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

JPG

use DefectiveCode\Faker\Generators\Jpg;
 
Faker::make(Jpg::class)
    ->width(800, 1920)          // Zufällige Breite zwischen 800-1920px
    ->height(600, 1080)         // Zufällige Höhe zwischen 600-1080px
    ->grid(5)                   // Optional: Generieren Sie ein 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

GIF

use DefectiveCode\Faker\Generators\Gif;
 
Faker::make(Gif::class)
    ->width(800, 1920)          // Zufällige Breite zwischen 800-1920px
    ->height(600, 1080)         // Zufällige Höhe zwischen 600-1080px
    ->withAlpha(true)           // Alpha-/Transparenzkanal aktivieren
    ->grid(5)                   // Optional: Generieren Sie ein 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

BMP

use DefectiveCode\Faker\Generators\Bmp;
 
Faker::make(Bmp::class)
    ->width(800, 1920)          // Zufällige Breite zwischen 800-1920px
    ->height(600, 1080)         // Zufällige Höhe zwischen 600-1080px
    ->grid(5)                   // Optional: Generieren Sie ein 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

WEBP

use DefectiveCode\Faker\Generators\Webp;
 
Faker::make(Webp::class)
    ->width(800, 1920)          // Zufällige Breite zwischen 800-1920px
    ->height(600, 1080)         // Zufällige Höhe zwischen 600-1080px
    ->withAlpha(true)           // Alpha-/Transparenzkanal aktivieren
    ->grid(5)                   // Optional: Generieren Sie ein 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

AVIF

use DefectiveCode\Faker\Generators\Avif;
 
Faker::make(Avif::class)
    ->width(800, 1920)          // Zufällige Breite zwischen 800-1920px
    ->height(600, 1080)         // Zufällige Höhe zwischen 600-1080px
    ->withAlpha(true)           // Alpha-/Transparenzkanal aktivieren
    ->grid(5)                   // Optional: Generieren Sie ein 5x5 symmetrisches Muster
    ->toDisk($filesystem)
    ->generate();

Zufälliges Bild

Generiert ein zufälliges Bildformat:

use DefectiveCode\Faker\Generators\RandomImage;
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(false)          // Zufällig von: AVIF, BMP, GIF, JPEG, PNG, WEBP
    ->toDisk($filesystem)
    ->generate();
 
Faker::make(RandomImage::class)
    ->width(800, 1920)
    ->height(600, 1080)
    ->withAlpha(true)           // Zufällig von: AVIF, GIF, PNG, WEBP
    ->toDisk($filesystem)
    ->generate();

🔗Textgenerator

Generieren Sie einfache Textdateien mit Absätzen:

use DefectiveCode\Faker\Generators\Text;
 
Faker::make(Text::class)
    ->paragraphs(5, 10)         // 5-10 Absätze pro Datei
    ->sentences(3, 6)           // 3-6 Sätze pro Absatz
    ->toDisk($filesystem)
    ->generate();

Beispielausgabe:

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
 
Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.

🔗CSV-Generator

Generieren Sie CSV-Dateien mit zufälligen Daten:

use DefectiveCode\Faker\Generators\Csv;
 
Faker::make(Csv::class)
    ->columns(5, 10)            // 5-10 Spalten
    ->rows(100, 500)            // 100-500 Zeilen
    ->delimiter(',')            // Spaltentrenner
    ->enclosure('"')            // Feldumhüllung
    ->escape('\\')              // Escape-Zeichen
    ->eol("\n")                 // Zeilenende
    ->toDisk($filesystem)
    ->generate();

Beispielausgabe:

"John Doe","john@example.com","555-1234","New York","Engineer"
"Jane Smith","jane@example.com","555-5678","Los Angeles","Designer"
"Bob Johnson","bob@example.com","555-9012","Chicago","Manager"

🔗Binärgenerator

Generieren Sie zufällige Binärdaten:

use DefectiveCode\Faker\Generators\Binary;
 
Faker::make(Binary::class)
    ->length(1024, 1048576)     // 1KB - 1MB
    ->toDisk($filesystem)
    ->generate();

🔗E-Mail-Generator

Generieren Sie RFC822-konforme E-Mail-Dateien:

use DefectiveCode\Faker\Generators\Email;
 
Faker::make(Email::class)
    ->paragraphs(3, 5)          // Absätze im E-Mail-Text
    ->sentences(2, 4)           // Sätze pro Absatz
    ->withAttachment(Png::class, 1, 3)  // Fügen Sie 1-3 PNG-Anhänge hinzu
    ->toDisk($filesystem)
    ->generate();

E-Mail-Header

Generierte E-Mails enthalten:

• To: Zufälliger Name und E-Mail
• From: Zufälliger Name und E-Mail
• Subject: Zufälliger Satz
• Date: Aktueller Zeitstempel
• Message-ID: Deterministische ID basierend auf dem Seed

E-Mail mit Anhängen

Fügen Sie Dateien mit den Generator-Klassennamen oder Instanzen hinzu:

use DefectiveCode\Faker\Generators\Email;
use DefectiveCode\Faker\Generators\Png;
use DefectiveCode\Faker\Generators\Pdf;
 
Faker::make(Email::class)
    ->withAttachment(Png::class, 1, 3)  // 1-3 PNG-Anhänge
    ->generate();
 
// Anhängen anhand der konfigurierten Generatorinstanz
$pngGenerator = new Png(Png::getDefaultConfig());
$pngGenerator->width(400, 800)->height(300, 600);
 
Faker::make(Email::class)
    ->withAttachment($pngGenerator, 2, 5)
    ->generate();

Beispielausgabe:

To: John Doe <john.doe@example.com>
From: Jane Smith <jane.smith@example.com>
Subject: Wichtige Besprechung morgen
Date: Fri, 03 Jan 2026 10:30:00 +0000
Message-ID: <3e92e5c2b0d632b3a36fbbb17484b7fe@example.com>
Content-Type: multipart/mixed; boundary="----=_Part_123"
 
------=_Part_123
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable
 
Lorem ipsum dolor sit amet, consectetur adipiscing elit...
 
------=_Part_123
Content-Type: image/png; name="attachment.png"
Content-Disposition: attachment; filename="attachment.png"
Content-Transfer-Encoding: base64
 
iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==
------=_Part_123--

🔗Erweiterte Nutzung

🔗Benutzerdefinierte Generatoren

Erstellen Sie Ihre eigenen Generatoren, indem Sie das Generator-Interface implementieren:

use DefectiveCode\Faker\Configs\Config;
use DefectiveCode\Faker\Concerns\SetsSeed;
use DefectiveCode\Faker\Generators\Generator;
use DefectiveCode\Faker\Concerns\PreparesFaker;
 
class MyCustomGenerator implements Generator
{
    use PreparesFaker;
    use SetsSeed;
 
    public function __construct(public Config $config) {}
 
    public static function getDefaultConfig(): Config
    {
        return new MyCustomConfig([
            'contentType' => 'application/x-custom',
            'nameGenerator' => NameGenerator::default('extension'),
        ]);
    }
 
    public function generate(): mixed
    {
        // Ihre Generierungslogik hier
        $data = $this->faker->randomElement(['foo', 'bar', 'baz']);
 
        $stream = fopen('php://temp', 'w+');
        fwrite($stream, $data);
 
        return $stream;
    }
}
 
// Verwenden Sie Ihren benutzerdefinierten Generator
Faker::make(MyCustomGenerator::class)
    ->toDisk($filesystem)
    ->generate();

🔗Konfigurationsklassen

Jeder Generator verwendet eine Konfigurationsklasse, die von Config abgeleitet ist:

use DefectiveCode\Faker\Configs\Config;
 
class MyCustomConfig extends Config
{
    public int $minValue = 1;
    public int $maxValue = 100;
}

🔗Leistungstipps

1. Verwenden Sie Swoole: Installieren Sie die Swoole-Erweiterung für die beste Leistung
2. Optimieren Sie die Nebenläufigkeit: Passen Sie die Thread-Anzahl an die CPU-Kerne für einen optimalen Durchsatz an
3. Batch-Operationen: Generieren Sie große Batches anstatt mehrere kleine Durchläufe
4. Speicherort: Verwenden Sie schnellen Speicher (SSD, lokale Festplatte) für temporäre Dateien, bevor Sie sie hochladen
5. Netzwerk-I/O: Erhöhen Sie die Nebenläufigkeit bei Verwendung von S3, um die Bandbreitennutzung zu maximieren

🔗Konfiguration

🔗Globale Konfigurationsmethoden

Diese Methoden sind auf allen Faker-Instanzen verfügbar:

make(string $generator): Faker

Erstellen Sie eine neue Faker-Instanz mit dem angegebenen Generator:

Faker::make(Png::class)

toDisk(Filesystem $filesystem): Faker

Legen Sie das Speicherziel fest (erforderlich):

Faker::make(Png::class)
    ->toDisk(new Filesystem(new LocalFilesystemAdapter('/storage')))

basePath(string $basePath): Faker

Legen Sie den Basis-Pfad innerhalb des Dateisystems fest:

Faker::make(Png::class)
    ->basePath('images/uploads')  // Dateien werden in /storage/images/uploads/ gespeichert

count(int $count): Faker

Legen Sie die Anzahl der zu generierenden Dateien fest:

Faker::make(Png::class)
    ->count(1000)

concurrency(int $threads, ?int $coroutines = null): Faker

Konfigurieren Sie die parallele Ausführung:

// Grundlegende Nebenläufigkeit
Faker::make(Png::class)
    ->concurrency(4)
 
// Swoole-spezifisch: Threads und Koroutinen
Faker::make(Png::class)
    ->concurrency(threads: 4, coroutines: 8)

seed(int $seed): Faker

Setzen Sie den Seed für die deterministische Generierung:

Faker::make(Png::class)
    ->seed(42)

nameGenerator(Closure $generator): Faker

Passen Sie die Dateibenennung an:

Faker::make(Png::class)
    ->nameGenerator(function (int $seed, int $completedFiles, $generator) {
        return "file-{$completedFiles}.png";
    })

diskOptions(array $diskOptions): Faker

Übergeben Sie Optionen an den Dateisystemadapter:

Faker::make(Png::class)
    ->diskOptions([
        'visibility' => 'public',
        'ACL' => 'public-read',
    ])

generate(): void

Führen Sie die Dateigenerierung aus:

Faker::make(Png::class)->generate();

🔗Support Richtlinien

Danke, dass Sie sich für unser Open-Source-Paket entschieden haben! Bitte nehmen Sie sich einen Moment Zeit, um diese Unterstützungsrichtlinien durchzulesen. Sie helfen Ihnen, das Beste aus unserem Projekt herauszuholen.

🔗Community-gesteuerte Unterstützung

Unser Open-Source-Projekt wird von unserer großartigen Community unterstützt. Wenn Sie Fragen haben oder Hilfe benötigen, sind StackOverflow und andere Online-Ressourcen Ihre besten Optionen.

🔗Bugs und Priorisierung von Funktionen

Die Realität des Managements eines Open-Source-Projekts bedeutet, dass wir nicht sofort jeden gemeldeten Fehler oder jede Funktionsanfrage angehen können. Wir priorisieren Probleme in der folgenden Reihenfolge:

1. Bugs, die unsere kostenpflichtigen Produkte betreffen

Bugs, die unsere kostenpflichtigen Produkte beeinträchtigen, haben immer die höchste Priorität. In einigen Fällen behandeln wir möglicherweise nur Bugs, die uns direkt betreffen.

2. Community Pull Requests

Wenn Sie einen Bug identifiziert haben und eine Lösung haben, reichen Sie bitte einen Pull Request ein. Nach den Problemen, die unsere Produkte betreffen, geben wir diesen community-gesteuerten Fehlerbehebungen die nächsthöchste Priorität. Sobald Ihr Lösungsvorschlag geprüft und genehmigt wurde, werden wir Ihre Lösung zusammenführen und Ihre Beiträge anerkennen.

3. Finanzielle Unterstützung

Für Probleme außerhalb der genannten Kategorien können Sie sich entscheiden, deren Lösung zu finanzieren. Jedes offene Problem ist mit einem Bestellformular verknüpft, über das Sie finanziell beitragen können. Wir priorisieren diese Probleme basierend auf dem bereitgestellten Finanzierungsbetrag.

Community-Beiträge

Open Source gedeiht, wenn seine Community aktiv ist. Auch wenn Sie keine Bugs beheben, ziehen Sie in Betracht, durch Codeverbesserungen, Dokumentationsaktualisierungen, Tutorials oder durch Unterstützung anderer in Community-Kanälen einen Beitrag zu leisten. Wir ermutigen alle, als Community zusammenzuarbeiten, um die Arbeit im Bereich Open Source zu unterstützen.

Nocht einmal: DefectiveCode wird Bugs priorisieren, basierend darauf, wie sie unsere kostenpflichtigen Produkte, Community-Pull-Requests und die finanzielle Unterstützung für Probleme beeinträchtigen.

🔗Lizenz - MIT Lizenz

Copyright © Defective Code, LLC. Alle Rechte vorbehalten

Hiermit wird jedermann, der eine Kopie dieser Software und der dazugehörigen Dokumentationsdateien (die "Software") erhält, kostenlos die Erlaubnis erteilt, die Software ohne Einschränkung zu nutzen, einschließlich, aber nicht beschränkt auf das Recht, die Software zu verwenden, zu kopieren, zu modifizieren, zusammenzuführen, zu veröffentlichen, zu vertreiben, Unterlizenzen zu erteilen und/oder Kopien der Software zu verkaufen, sowie Personen, denen die Software bereitgestellt wird, dies zu gestatten, vorbehaltlich der folgenden Bedingungen:

Die obige Urheberrechtshinweis und diese Erlaubnismitteilung sind in allen Kopien oder wesentlichen Teilen der Software enthalten.

DIE SOFTWARE WIRD "WIE BESEHEN" BEREITGESTELLT, OHNE GARANTIE IRGENDWELCHER ART, WEDER AUSDRÜCKLICH NOCH STILLSCHWEIGEND, EINSCHLIESSLICH, ABER NICHT BEGRENZT AUF DIE GARANTIEN DER MARKTFÄHIGKEIT, EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND NICHTVERLETZUNG. IN KEINEM FALL SIND DIE AUTOREN ODER URHEBERRECHTSINHABER FÜR IRGENDEINEN ANSPRUCH, SCHÄDEN ODER ANDERE HAFTUNGEN HAFTBAR, OB IN EINER KLAUSEL FÜR VERTRAG, DELIKT ODER ANDERS, DIE AUS DER SOFTWARE ODER DER NUTZUNG ODER ANDEREN GEHEIMNISSEN IN DER SOFTWARE ENTSTEHEN.