<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!--

    Copyright (c) 2014, 2018 Oracle and/or its affiliates. All rights reserved.

    This program and the accompanying materials are made available under the
    terms of the Eclipse Public License v. 2.0, which is available at
    http://www.eclipse.org/legal/epl-2.0.

    This Source Code may also be made available under the following Secondary
    Licenses when the conditions for such availability set forth in the
    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
    version 2 with the GNU Classpath Exception, which is available at
    https://www.gnu.org/software/classpath/license.html.

    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0

-->

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">

    <title>Test data generation tool for Jersey performance tests</title>

    <!-- Bootstrap -->
    <link href="http://netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>

<div class="container">
    <div class="row">
        <div class="col-lg-offset-1 col-lg-10">
            <header class="page-header">
                <h1>Test data generation tool for Jersey performance tests</small></h1>
            </header>

            <p>
                This module contains a simple tool to generate data sets for performance testing. It generates three
                distinct media types: xml, json and plain text, each in a variety of predefined data set sizes (1kB,
                5kB, 10kB, 1MB and optionally 1GB).
            </p>

            <p>
                The generation of the largest files (1GB) is disabled by default to save disk space and shorten the
                generation time. To enable it, change the value of the <pre>GENERATE_ALSO_GIGABYTE_DATASETS</pre>
            constant in the <pre>TestDataGeneratorApp</pre> class to true.
            </p>

            <h2>Running the Example</h2>

            <p>Run the example as follows:</p>
            <blockquote>
                <pre>mvn clean compile exec:java</pre>
            </blockquote>

            <p>
                You can tweak the values of several constants in the <pre>TestDataGeneratorApp</pre> class before
            launching the generation. For more information, please see the javadocs.
            The above command launches a Grizzly server with the generation server-side app and runs a client with
            predefined parameters against it.
            </p>
        </div>
    </div>
</div>

<script src="http://netdna.bootstrapcdn.com/bootstrap/3.0.0/js/bootstrap.min.js"></script>
</body>
</html>
