public void test01DeleteRelationship() {

    try {

      final TestSix testSix  = createTestNode(TestSix.class);

      SixOneOneToOne rel     = null;

      assertNotNull(testOne);

      assertNotNull(testSix);

    final String numberString2        = numberFormat2.format(2.234);

    final String numberString3        = numberFormat3.format(2.234);

    MailTemplate template             = null;

    MailTemplate template2             = null;

    TestTwo testTwo                   = null;

    TestThree testThree               = null;

    TestFour testFour                 = null;

    List<TestSix> testSixs            = null;

    int index                         = 0;

    try (final Tx tx = app.tx()) {

      testOne        = createTestNode(TestOne.class);

      testTwo        = createTestNode(TestTwo.class);

      testThree      = createTestNode(TestThree.class);

      testFour       = createTestNode(TestFour.class);

      testSixs       = createTestNodes(TestSix.class, 20);

      for (final TestSix testSix : testSixs) {

        testSix.setProperty(TestSix.index, index++);

      }

      // create mail template

      template = createTestNode(MailTemplate.class);

      template.setProperty(MailTemplate.name, "TEST");

      template.setProperty(MailTemplate.locale, "en_EN");

      template.setProperty(MailTemplate.text, "This is a template for ${this.name}");

      // create mail template

      template2 = createTestNode(MailTemplate.class);

      template2.setProperty(MailTemplate.name, "TEST2");

      template2.setProperty(MailTemplate.locale, "en_EN");

      template2.setProperty(MailTemplate.text, "${this.aDouble}");

      // check existance

      assertNotNull(testOne);

      tx.success();

    } catch (FrameworkException fex) {

      fex.printStackTrace();

      fail("Unexpected exception");

    }

    try (final Tx tx = app.tx()) {

      final ActionContext ctx = new ActionContext(testOne, null);

      // test for "empty" return value

      assertEquals("${this} should evaluate to the current node", testTwo.toString(), testTwo.replaceVariables(securityContext, ctx, "${this}"));

      try {

        fail("A mismatched opening bracket should throw an exception.");

      } catch (FrameworkException fex) {

        assertEquals("Invalid expression: mismatched closing bracket after this.alwaysNull.size", fex.getMessage());

      }

      // test with property

      // test literal value as well

      // join

      // concat

      // split

      // abbr

      // capitalize..

      // titleize

      // num (explicit number conversion)

      // index_of

      // contains

      // substring

      // length

      // clean

      // urlencode

      // escape_javascript

      // if etc.

      // empty

      // functions can NOT handle literal strings containing newlines  (disabled for now, because literal strings pose problems in the matching process)

      // functions CAN handle variable values with newlines!

      // equal

      // if + equal

      // disabled: java StreamTokenizer can NOT handle scientific notation

//      assertEquals("Invalid if(equal()) result", "true",  testOne.replaceVariables(securityContext, ctx, "${equal(23.4462, 2.34462e1)}"));

//      assertEquals("Invalid if(equal()) result", "true",  testOne.replaceVariables(securityContext, ctx, "${equal(0.00234462, 2.34462e-3)}"));

//      assertEquals("Invalid if(equal()) result with null value", "false",  testOne.replaceVariables(securityContext, ctx, "${equal(this.alwaysNull, 2.34462e-3)}"));

      // if + equal + add

      // add with null

      // if + lt

      // lt with null

      // if + gt

      // gt with null

      // if + lte

      // lte with null

      // if + gte

      // gte with null

      // if + equal + subt

      // subt with null

      // if + equal + mult

      // mult with null

      // if + equal + quot

      // quot with null

      // if + equal + round

      // disabled because scientific notation is not supported :(

      //assertEquals("Invalid if(equal(round())) result", "true",  testOne.replaceVariables(securityContext, ctx, "${if(equal(0.00245, round(2.45e-3, 8)), \"true\", \"false\")}"));

      //assertEquals("Invalid if(equal(round())) result", "true",  testOne.replaceVariables(securityContext, ctx, "${if(equal(245, round(2.45e2, 8)), \"true\", \"false\")}"));

      // round with null

      // if + equal + max

      // max with null

      // if + equal + min

      // min with null

      // date_format

      // date_format with null

      // date_format error messages

      // number_format error messages

      // number_format with null

      // not

      // not with null

      // and

      // and with null

      // or

      // or with null

      // get

      // size

      // is_collection

      // is_entity

      // first / last / nth

      // first / last / nth with null

      // each with null

      // get with null

      // set with null

      // geocode with null

      // send_plaintex_mail with null

      // send_html_mail with null

      // read with null

      // write with null

      // append with null

      // xml with null

      // xpath with null

      // find with null

      // do

      // template method

      // more complex tests

      // complex each expression, sets the value of "testString" to the concatenated IDs of all testSixs that are linked to "this"

      // tests from real-life examples

      // more tests with pre- and postfixes

      // test store and retrieve

      assertEquals("Invalid stored value", "A-nice-little-name-for-my-test-object", ctx.retrieve("tmp"));

      // test store and retrieve within filter expression

      // test replace() method

      // test error method

      try {

        Actions.execute(securityContext, testTwo, "${error(\"base\", \"test1\")}");

        fail("error() should throw an exception.");

      } catch (FrameworkException fex) { }

      try {

        Actions.execute(securityContext, testTwo, "${error(\"base\", \"test1\", \"test2\")}");

        fail("error() should throw an exception.");

      } catch (FrameworkException fex) { }

      // test multiline statements

      // test default values

      // Number default value

      // complex multi-statement tests

      // test multiple nested dot-separated properties (this.parent.parent.parent)

      // test extract() with additional evaluation function

      // test complex multiline statement replacement

      final String test =

        "${if(lte(template('TEST2', 'en_EN', this), 2), '<2', '>2')}\n" +    // first expression should evaluate to ">2"

        "${if(lte(template('TEST2', 'en_EN', this), 3), '<3', '>3')}"      // second expression should evaluate to "<3"

      ;

      assertEquals("Invalid multiline and template() result", ">2\n<3", result);

      tx.success();

    try {

   

      TestUser user1 = null;

      TestUser user2 = null;

      Class type = TestOne.class;

      final App superUserApp = StructrApp.getInstance();

      try (final Tx tx = app.tx()) {

        List<TestUser> users = createTestNodes(TestUser.class, 2);

        user1 = (TestUser) users.get(0);

        user1.setProperty(AbstractNode.name, "user1");

       

        user2 = (TestUser) users.get(1);

        user2.setProperty(AbstractNode.name, "user2");

        t1 = createTestNode(TestOne.class);

        tx.success();

      } catch (FrameworkException ex) {

        logger.log(Level.SEVERE, ex.toString());

      }

      try (final Tx tx = app.tx()) {

       

        // Switch user context to user1

        final App user1App = StructrApp.getInstance(SecurityContext.getInstance(user1, AccessMode.Backend));

        // Check if user1 can see t1

        assertEquals(t1, user1App.nodeQuery(type, false).getFirst());

      }

     

      try (final Tx tx = app.tx()) {

        // As superuser, make another user the owner

        tx.success();

       

      } catch (FrameworkException ex) {

        logger.log(Level.SEVERE, ex.toString());