/**
   * Assuming given tables have schema metadata, fill them with random data and compare a pure-java
   * schema migration with an EE schema migration.
   */
  void migrateSchema(VoltTable t1, VoltTable t2, boolean withData) throws Exception {
    ServerThread server = null;
    Client client = null;
    TableHelper helper = new TableHelper();

    try {
      if (withData) {
        helper.randomFill(t1, 1000, 1024);
      }

      String catPath1 = catalogPathForTable(t1, "t1.jar");
      String catPath2 = catalogPathForTable(t2, "t2.jar");
      byte[] catBytes2 = MiscUtils.fileToBytes(new File(catPath2));

      DeploymentBuilder depBuilder = new DeploymentBuilder(1, 1, 0);
      depBuilder.setVoltRoot("/tmp/foobar");
      // disable logging
      depBuilder.configureLogging("/tmp/foobar", "/tmp/foobar", false, false, 1, 1, 3);
      String deployment = depBuilder.getXML();
      File deploymentFile = VoltProjectBuilder.writeStringToTempFile(deployment);

      VoltDB.Configuration config = new VoltDB.Configuration();
      config.m_pathToDeployment = deploymentFile.getAbsolutePath();
      config.m_pathToCatalog = catPath1;
      config.m_ipcPort = 10000;
      // config.m_backend = BackendTarget.NATIVE_EE_IPC;
      server = new ServerThread(config);
      server.start();
      server.waitForInitialization();

      System.out.printf("PRE:  %s\n", TableHelper.ddlForTable(t1));
      System.out.printf("POST: %s\n", TableHelper.ddlForTable(t2));

      ClientConfig clientConfig = new ClientConfig();
      client = ClientFactory.createClient(clientConfig);
      client.createConnection("localhost");

      TableHelper.loadTable(client, t1);

      ClientResponseImpl response =
          (ClientResponseImpl) client.callProcedure("@UpdateApplicationCatalog", catBytes2, null);
      System.out.println(response.toJSONString());

      VoltTable t3 = client.callProcedure("@AdHoc", "select * from FOO").getResults()[0];
      t3 = TableHelper.sortTable(t3);

      // compute the migrated table entirely in Java for comparison purposes
      TableHelper.migrateTable(t1, t2);
      t2 = TableHelper.sortTable(t2);

      // compare the tables
      StringBuilder sb = new StringBuilder();
      if (!TableHelper.deepEqualsWithErrorMsg(t2, t3, sb)) {
        System.out.println("Table Mismatch");
        // System.out.printf("PRE:  %s\n", t2.toFormattedString());
        // System.out.printf("POST: %s\n", t3.toFormattedString());
        System.out.println(sb.toString());
        fail();
      }
    } finally {
      if (client != null) {
        client.close();
      }
      if (server != null) {
        server.shutdown();
      }
    }
  }
  public void testBasic() throws Exception {
    System.out.println("\n\n-----\n testBasic \n-----\n\n");

    String pathToCatalog = Configuration.getPathToCatalogForTest("adhocddl.jar");
    String pathToDeployment = Configuration.getPathToCatalogForTest("adhocddl.xml");
    VoltProjectBuilder builder = new VoltProjectBuilder();
    // Need to parallel dbuilder as we modify builder
    DeploymentBuilder dbuilder = new DeploymentBuilder(2, 1, 0);
    builder.addLiteralSchema(
        "create table FOO ("
            + "ID integer not null,"
            + "VAL bigint, "
            + "constraint PK_TREE primary key (ID)"
            + ");\n"
            + "create table FOO_R ("
            + "ID integer not null,"
            + "VAL bigint, "
            + "constraint PK_TREE_R primary key (ID)"
            + ");\n");
    builder.addPartitionInfo("FOO", "ID");
    dbuilder.setUseDDLSchema(true);
    // Use random caps in role names to check case-insensitivity
    dbuilder.addUsers(
        new DeploymentBuilder.UserInfo[] {
          new DeploymentBuilder.UserInfo("admin", "admin", new String[] {"Administrator"})
        });
    dbuilder.setSecurityEnabled(true);
    dbuilder.setEnableCommandLogging(false);
    boolean success = builder.compile(pathToCatalog, 2, 1, 0);
    assertTrue("Schema compilation failed", success);
    dbuilder.writeXML(pathToDeployment);
    // MiscUtils.copyFile(builder.getPathToDeployment(), pathToDeployment);

    VoltDB.Configuration config = new VoltDB.Configuration();
    config.m_pathToCatalog = pathToCatalog;
    config.m_pathToDeployment = pathToDeployment;

    try {
      startServer(config);
      ClientConfig adminConfig = new ClientConfig("admin", "admin");
      Client adminClient = ClientFactory.createClient(adminConfig);
      ClientConfig userConfig = new ClientConfig("user", "user");
      Client userClient = ClientFactory.createClient(userConfig);

      adminClient.createConnection("localhost");
      // Can't connect a user which doesn't exist
      boolean threw = false;
      try {
        userClient.createConnection("localhost");
      } catch (IOException ioe) {
        threw = true;
        assertTrue(ioe.getMessage().contains("Authentication rejected"));
      }
      assertTrue("Connecting bad user should have failed", threw);

      // Add the user with the new role
      dbuilder.addUsers(new UserInfo[] {new UserInfo("user", "user", new String[] {"NEWROLE"})});
      dbuilder.writeXML(pathToDeployment);
      try {
        adminClient.updateApplicationCatalog(null, new File(pathToDeployment));
      } catch (ProcCallException pce) {
        pce.printStackTrace();
        fail("Should be able to add a user even with a role that doesn't exist");
      }

      // Check that we can connect the new user
      try {
        userClient.createConnection("localhost");
      } catch (IOException ioe) {
        ioe.printStackTrace();
        fail("Should have been able to connect 'user'");
      }

      // Make sure the user doesn't actually have DEFAULTPROC permissions yet
      threw = false;
      try {
        userClient.callProcedure("FOO.insert", 0, 0);
      } catch (ProcCallException pce) {
        pce.printStackTrace();
        threw = true;
      }
      assertTrue("'user' shouldn't be able to call procedures yet", threw);

      // Okay, it's showtime.  Let's add the role through live DDL
      try {
        adminClient.callProcedure("@AdHoc", "create role NEWROLE with DEFAULTPROC");
      } catch (ProcCallException pce) {
        pce.printStackTrace();
        fail("Creating role should have succeeded");
      }

      try {
        adminClient.updateApplicationCatalog(null, new File(pathToDeployment));
      } catch (ProcCallException pce) {
        pce.printStackTrace();
        fail("Adding 'user' should have succeeded this time");
      }

      // Make sure the user now has DEFAULTPROC permissions
      try {
        userClient.callProcedure("FOO.insert", 0, 0);
      } catch (ProcCallException pce) {
        pce.printStackTrace();
        fail("'user' should be able to call default procs now");
      }

      threw = false;
      try {
        adminClient.callProcedure("@AdHoc", "create role NEWROLE with ALLPROC");
      } catch (ProcCallException pce) {
        assertTrue(pce.getMessage().contains("already exists"));
        threw = true;
      }
      assertTrue("Shouldn't be able to 'create' same role twice", threw);

      threw = false;
      try {
        // Use random caps in role names to check case-insensitivity
        adminClient.callProcedure("@AdHoc", "create role aDministrator with ALLPROC");
      } catch (ProcCallException pce) {
        assertTrue(pce.getMessage().contains("already exists"));
        threw = true;
      }
      assertTrue("Shouldn't be able to 'create' ADMINISTRATOR role", threw);

      threw = false;
      try {
        adminClient.callProcedure("@AdHoc", "create role USER with ALLPROC");
      } catch (ProcCallException pce) {
        assertTrue(pce.getMessage().contains("already exists"));
        threw = true;
      }
      assertTrue("Shouldn't be able to 'create' USER role", threw);

      try {
        adminClient.callProcedure("@AdHoc", "drop role NEWROLE;");
      } catch (ProcCallException pce) {
        pce.printStackTrace();
        fail("Should be able to drop role NEWROLE");
      }

      // Can't drop twice
      try {
        adminClient.callProcedure("@AdHoc", "drop role NEWROLE;");
      } catch (ProcCallException pce) {
        pce.printStackTrace();
        threw = true;
      }
      assertTrue("Can't vanilla DROP a role which doesn't exist", threw);

      // unless you use IF EXISTS
      try {
        adminClient.callProcedure("@AdHoc", "drop role NEWROLE if exists;");
      } catch (ProcCallException pce) {
        pce.printStackTrace();
        fail("Should be able to drop role NEWROLE if exists");
      }

      // Make sure the user doesn't actually have DEFAULTPROC permissions any more
      threw = false;
      try {
        userClient.callProcedure("FOO.insert", 0, 0);
      } catch (ProcCallException pce) {
        pce.printStackTrace();
        threw = true;
      }
      assertTrue("'user' shouldn't be able to call procedures yet", threw);

      threw = false;
      try {
        adminClient.callProcedure("@AdHoc", "drop role USER;");
      } catch (ProcCallException pce) {
        threw = true;
        assertTrue(pce.getMessage().contains("You may not drop the built-in role"));
        pce.printStackTrace();
      }
      assertTrue("Shouldn't be able to drop role USER", threw);

      // CHeck the administrator error message, there should end up being multiple
      // reasons why we can't get rid of this role (like, we will require you to always
      // have a user with this role)
      threw = false;
      try {
        // Use random caps in role names to check case-insensitivity
        adminClient.callProcedure("@AdHoc", "drop role adMinistrator;");
      } catch (ProcCallException pce) {
        threw = true;
        assertTrue(pce.getMessage().contains("You may not drop the built-in role"));
        pce.printStackTrace();
      }
      assertTrue("Shouldn't be able to drop role ADMINISTRATOR", threw);

      // Make sure that we can't get rid of the administrator user
      dbuilder.removeUser("admin");
      dbuilder.writeXML(pathToDeployment);
      threw = false;
      try {
        adminClient.updateApplicationCatalog(null, new File(pathToDeployment));
      } catch (ProcCallException pce) {
        pce.printStackTrace();
        threw = true;
      }
      assertTrue("Shouldn't be able to remove the last remaining ADMINSTRATOR user", threw);
    } finally {
      teardownSystem();
    }
  }