Examples with Out org.h2.dev.util.BinaryArithmeticStream.Out used on opensource projects

Example 11 with Out

use of org.h2.dev.util.BinaryArithmeticStream.Out in project h2database by h2database.

the class TestTools method testWrongServer.

private void testWrongServer() throws Exception {
    // try to connect when the server is not running
    assertThrows(ErrorCode.CONNECTION_BROKEN_1, this).getConnection("jdbc:h2:tcp://localhost:9001/test");
    final ServerSocket serverSocket = new ServerSocket(9001);
    Task task = new Task() {

        @Override
        public void call() throws Exception {
            while (!stop) {
                Socket socket = serverSocket.accept();
                byte[] data = new byte[1024];
                data[0] = 'x';
                OutputStream out = socket.getOutputStream();
                out.write(data);
                out.close();
                socket.close();
            }
        }
    };
    try {
        task.execute();
        Thread.sleep(100);
        try {
            getConnection("jdbc:h2:tcp://localhost:9001/test");
            fail();
        } catch (SQLException e) {
            assertEquals(ErrorCode.CONNECTION_BROKEN_1, e.getErrorCode());
        }
    } finally {
        serverSocket.close();
        task.getException();
    }
}

Example 12 with Out

use of org.h2.dev.util.BinaryArithmeticStream.Out in project h2database by h2database.

the class TestRecovery method testRunScript.

private void testRunScript() throws SQLException {
    DeleteDbFiles.execute(getBaseDir(), "recovery", true);
    DeleteDbFiles.execute(getBaseDir(), "recovery2", true);
    org.h2.Driver.load();
    Connection conn = getConnection("recovery");
    Statement stat = conn.createStatement();
    stat.execute("create table \"Joe\"\"s Table\" as " + "select 1");
    stat.execute("create table test as " + "select * from system_range(1, 100)");
    stat.execute("create view \"TEST VIEW OF TABLE TEST\" as " + "select * from test");
    stat.execute("create table a(id int primary key) as " + "select * from system_range(1, 100)");
    stat.execute("create table b(id int references a(id)) as " + "select * from system_range(1, 100)");
    stat.execute("create table lob(c clob, b blob) as " + "select space(10000) || 'end', SECURE_RAND(10000)");
    stat.execute("create table d(d varchar) as " + "select space(10000) || 'end'");
    stat.execute("alter table a add foreign key(id) references b(id)");
    // all rows have the same value - so that SCRIPT can't re-order the rows
    stat.execute("create table e(id varchar) as " + "select space(10) from system_range(1, 1000)");
    stat.execute("create index idx_e_id on e(id)");
    conn.close();
    Recover rec = new Recover();
    ByteArrayOutputStream buff = new ByteArrayOutputStream();
    rec.setOut(new PrintStream(buff));
    rec.runTool("-dir", getBaseDir(), "-db", "recovery", "-trace");
    String out = new String(buff.toByteArray());
    assertContains(out, "Created file");
    Connection conn2 = getConnection("recovery2");
    Statement stat2 = conn2.createStatement();
    String name = "recovery.h2.sql";
    stat2.execute("runscript from '" + getBaseDir() + "/" + name + "'");
    stat2.execute("select * from test");
    conn2.close();
    conn = getConnection("recovery");
    stat = conn.createStatement();
    conn2 = getConnection("recovery2");
    stat2 = conn2.createStatement();
    assertEqualDatabases(stat, stat2);
    conn.close();
    conn2.close();
    Recover.execute(getBaseDir(), "recovery");
    deleteDb("recovery");
    deleteDb("recovery2");
    FileUtils.delete(getBaseDir() + "/recovery.h2.sql");
    String dir = getBaseDir() + "/recovery.lobs.db";
    FileUtils.deleteRecursive(dir, false);
}

Example 13 with Out

use of org.h2.dev.util.BinaryArithmeticStream.Out in project h2database by h2database.

the class TestShell method test.

private void test(final boolean commandLineArgs) throws IOException {
    PipedInputStream testIn = new PipedInputStream();
    PipedOutputStream out = new PipedOutputStream(testIn);
    toolOut = new PrintStream(out, true);
    out = new PipedOutputStream();
    PrintStream testOut = new PrintStream(out, true);
    toolIn = new PipedInputStream(out);
    Task task = new Task() {

        @Override
        public void call() throws Exception {
            try {
                Shell shell = new Shell();
                shell.setIn(toolIn);
                shell.setOut(toolOut);
                shell.setErr(toolOut);
                if (commandLineArgs) {
                    shell.runTool("-url", "jdbc:h2:mem:", "-user", "sa", "-password", "sa");
                } else {
                    shell.runTool();
                }
            } finally {
                toolOut.close();
            }
        }
    };
    task.execute();
    InputStreamReader reader = new InputStreamReader(testIn);
    lineReader = new LineNumberReader(reader);
    read("");
    read("Welcome to H2 Shell");
    read("Exit with");
    if (!commandLineArgs) {
        read("[Enter]");
        testOut.println("jdbc:h2:mem:");
        read("URL");
        testOut.println("");
        read("Driver");
        testOut.println("sa");
        read("User");
        testOut.println("sa");
        read("Password");
    }
    read("Commands are case insensitive");
    read("help or ?");
    read("list");
    read("maxwidth");
    read("autocommit");
    read("history");
    read("quit or exit");
    read("");
    testOut.println("history");
    read("sql> No history");
    testOut.println("1");
    read("sql> Not found");
    testOut.println("select 1 a;");
    read("sql> A");
    read("1");
    read("(1 row,");
    testOut.println("history");
    read("sql> #1: select 1 a");
    read("To re-run a statement, type the number and press and enter");
    testOut.println("1");
    read("sql> select 1 a");
    read("A");
    read("1");
    read("(1 row,");
    testOut.println("select 'x' || space(1000) large, 'y' small;");
    read("sql> LARGE");
    read("x");
    read("(data is partially truncated)");
    read("(1 row,");
    testOut.println("select x, 's' s from system_range(0, 10001);");
    read("sql> X    | S");
    for (int i = 0; i < 10000; i++) {
        read((i + "     ").substring(0, 4) + " | s");
    }
    for (int i = 10000; i <= 10001; i++) {
        read((i + "     ").substring(0, 5) + " | s");
    }
    read("(10002 rows,");
    testOut.println("select error;");
    read("sql> Error:");
    if (read("").startsWith("Column \"ERROR\" not found")) {
        read("");
    }
    testOut.println("create table test(id int primary key, name varchar)\n;");
    read("sql> ...>");
    testOut.println("insert into test values(1, 'Hello');");
    read("sql>");
    testOut.println("select null n, * from test;");
    read("sql> N    | ID | NAME");
    read("null | 1  | Hello");
    read("(1 row,");
    // test history
    for (int i = 0; i < 30; i++) {
        testOut.println("select " + i + " ID from test;");
        read("sql> ID");
        read("" + i);
        read("(1 row,");
    }
    testOut.println("20");
    read("sql> select 10 ID from test");
    read("ID");
    read("10");
    read("(1 row,");
    testOut.println("maxwidth");
    read("sql> Usage: maxwidth <integer value>");
    read("Maximum column width is now 100");
    testOut.println("maxwidth 80");
    read("sql> Maximum column width is now 80");
    testOut.println("autocommit");
    read("sql> Usage: autocommit [true|false]");
    read("Autocommit is now true");
    testOut.println("autocommit false");
    read("sql> Autocommit is now false");
    testOut.println("autocommit true");
    read("sql> Autocommit is now true");
    testOut.println("list");
    read("sql> Result list mode is now on");
    testOut.println("select 1 first, 2 second;");
    read("sql> FIRST : 1");
    read("SECOND: 2");
    read("(1 row, ");
    testOut.println("select x from system_range(1, 3);");
    read("sql> X: 1");
    read("");
    read("X: 2");
    read("");
    read("X: 3");
    read("(3 rows, ");
    testOut.println("select x, 2 as y from system_range(1, 3) where 1 = 0;");
    read("sql> X");
    read("Y");
    read("(0 rows, ");
    testOut.println("list");
    read("sql> Result list mode is now off");
    testOut.println("help");
    read("sql> Commands are case insensitive");
    read("help or ?");
    read("list");
    read("maxwidth");
    read("autocommit");
    read("history");
    read("quit or exit");
    read("");
    testOut.println("exit");
    read("sql>");
    task.get();
}

Example 14 with Out

use of org.h2.dev.util.BinaryArithmeticStream.Out in project h2database by h2database.

the class TestStreams method testLZFStreams.

private void testLZFStreams() throws IOException {
    Random random = new Random(1);
    int max = getSize(100, 1000);
    for (int i = 0; i < max; i += 3) {
        byte[] buffer = getRandomBytes(random);
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        LZFOutputStream comp = new LZFOutputStream(out);
        if (random.nextInt(10) == 1) {
            comp.write(buffer);
        } else {
            for (int j = 0; j < buffer.length; ) {
                int[] sizes = { 0, 1, random.nextInt(100), random.nextInt(100000) };
                int size = sizes[random.nextInt(sizes.length)];
                size = Math.min(size, buffer.length - j);
                if (size == 1) {
                    comp.write(buffer[j]);
                } else {
                    comp.write(buffer, j, size);
                }
                j += size;
            }
        }
        comp.close();
        byte[] compressed = out.toByteArray();
        ByteArrayInputStream in = new ByteArrayInputStream(compressed);
        LZFInputStream decompress = new LZFInputStream(in);
        byte[] test = new byte[buffer.length];
        for (int j = 0; j < buffer.length; ) {
            int[] sizes = { 0, 1, random.nextInt(100), random.nextInt(100000) };
            int size = sizes[random.nextInt(sizes.length)];
            if (size == 1) {
                int x = decompress.read();
                if (x < 0) {
                    break;
                }
                test[j++] = (byte) x;
            } else {
                size = Math.min(size, test.length - j);
                int l = decompress.read(test, j, size);
                if (l < 0) {
                    break;
                }
                j += l;
            }
        }
        decompress.close();
        assertEquals(buffer, test);
    }
}

Example 15 with Out

use of org.h2.dev.util.BinaryArithmeticStream.Out in project h2database by h2database.

the class TestFileSystem method testZipFileSystem.

private void testZipFileSystem(String prefix, Random r) throws IOException {
    byte[] data = new byte[r.nextInt(16 * 1024)];
    long x = r.nextLong();
    FilePath file = FilePath.get(getBaseDir() + "/fs/readonly" + x + ".zip");
    r.nextBytes(data);
    OutputStream out = file.newOutputStream(false);
    ZipOutputStream zipOut = new ZipOutputStream(out);
    ZipEntry entry = new ZipEntry("data");
    zipOut.putNextEntry(entry);
    zipOut.write(data);
    zipOut.closeEntry();
    zipOut.close();
    out.close();
    FilePath fp = FilePath.get(prefix + getBaseDir() + "/fs/readonly" + x + ".zip!data");
    FileChannel fc = fp.open("r");
    StringBuilder buff = new StringBuilder();
    try {
        int pos = 0;
        for (int i = 0; i < 100; i++) {
            trace("op " + i);
            switch(r.nextInt(5)) {
                case 0:
                    {
                        int p = r.nextInt(data.length);
                        trace("seek " + p);
                        buff.append("seek " + p + "\n");
                        fc.position(p);
                        pos = p;
                        break;
                    }
                case 1:
                    {
                        int len = r.nextInt(1000);
                        int offset = r.nextInt(100);
                        int arrayLen = len + offset;
                        len = Math.min(len, data.length - pos);
                        byte[] b1 = new byte[arrayLen];
                        byte[] b2 = new byte[arrayLen];
                        trace("readFully " + len);
                        buff.append("readFully " + len + "\n");
                        System.arraycopy(data, pos, b1, offset, len);
                        ByteBuffer byteBuff = createSlicedBuffer(b2, offset, len);
                        FileUtils.readFully(fc, byteBuff);
                        assertEquals(b1, b2);
                        pos += len;
                        break;
                    }
                case 2:
                    {
                        int len = r.nextInt(1000);
                        int offset = r.nextInt(100);
                        int arrayLen = len + offset;
                        int p = r.nextInt(data.length);
                        len = Math.min(len, data.length - p);
                        byte[] b1 = new byte[arrayLen];
                        byte[] b2 = new byte[arrayLen];
                        trace("readFully " + p + " " + len);
                        buff.append("readFully " + p + " " + len + "\n");
                        System.arraycopy(data, p, b1, offset, len);
                        ByteBuffer byteBuff = createSlicedBuffer(b2, offset, len);
                        DataUtils.readFully(fc, p, byteBuff);
                        assertEquals(b1, b2);
                        break;
                    }
                case 3:
                    {
                        trace("getFilePointer");
                        buff.append("getFilePointer\n");
                        assertEquals(pos, fc.position());
                        break;
                    }
                case 4:
                    {
                        trace("length " + data.length);
                        buff.append("length " + data.length + "\n");
                        assertEquals(data.length, fc.size());
                        break;
                    }
                default:
            }
        }
        fc.close();
        file.delete();
    } catch (Throwable e) {
        e.printStackTrace();
        fail("Exception: " + e + "\n" + buff.toString());
    }
}