Пример #1
0
  /**
   *
   *
   * <pre>
   *             or
   *         /        \
   *       and         or
   *      /  \         / \
   * descr descr2 descr3 descr4
   * </pre>
   *
   * result:<br>
   * descr && descr2<br>
   * or<br>
   * descr3<br>
   * or<br>
   * descr4
   */
  @Test
  public void testAddOrAndOr() {
    Pattern pattern = VerifierComponentMockFactory.createPattern1();

    LiteralRestriction literalRestriction = LiteralRestriction.createRestriction(pattern, "");
    LiteralRestriction literalRestriction2 = LiteralRestriction.createRestriction(pattern, "");
    LiteralRestriction literalRestriction3 = LiteralRestriction.createRestriction(pattern, "");
    LiteralRestriction literalRestriction4 = LiteralRestriction.createRestriction(pattern, "");

    PatternSolver solver = new PatternSolver(pattern);

    solver.addOperator(OperatorDescrType.OR);
    solver.addOperator(OperatorDescrType.AND);
    solver.add(literalRestriction);
    solver.add(literalRestriction2);
    solver.end();
    solver.addOperator(OperatorDescrType.OR);
    solver.add(literalRestriction3);
    solver.add(literalRestriction4);
    solver.end();
    solver.end();

    List<Set<VerifierComponent>> list = solver.getPossibilityLists();
    assertEquals(3, list.size());

    assertEquals(2, list.get(0).size());
    assertTrue(list.get(0).contains(literalRestriction));
    assertTrue(list.get(0).contains(literalRestriction2));

    assertEquals(1, list.get(1).size());
    assertTrue(list.get(1).contains(literalRestriction3));

    assertEquals(1, list.get(2).size());
    assertTrue(list.get(2).contains(literalRestriction4));
  }
Пример #2
0
  @Test
  public void testPatternPossibilities() throws Exception {
    StatelessSession session =
        getStatelessSession(this.getClass().getResourceAsStream("Rules.drl"));

    session.setAgendaFilter(
        new RuleNameMatchesAgendaFilter("Rule possibility that is always true"));

    VerifierReport result = VerifierReportFactory.newVerifierReport();
    Collection<Object> data = new ArrayList<Object>();

    session.setGlobal("result", result);

    // This rule is always true.
    VerifierRule rule1 = VerifierComponentMockFactory.createRule1();
    Pattern pattern1 = VerifierComponentMockFactory.createPattern1();

    SubRule rp1 = new SubRule(rule1, 0);
    SubPattern pp1 = new SubPattern(pattern1, 0);
    AlwaysTrue alwaysTrue1 = new AlwaysTrue(pp1);
    SubPattern pp2 = new SubPattern(pattern1, 1);
    AlwaysTrue alwaysTrue2 = new AlwaysTrue(pp2);

    rp1.add(pp1);
    rp1.add(pp2);

    // This rule is okay.
    VerifierRule rule2 = VerifierComponentMockFactory.createRule2();
    Pattern pattern2 = VerifierComponentMockFactory.createPattern2();

    SubRule rp2 = new SubRule(rule2, 0);
    SubPattern pp3 = new SubPattern(pattern2, 0);
    SubPattern pp4 = new SubPattern(pattern2, 1);
    AlwaysTrue alwaysTrue4 = new AlwaysTrue(pp4);

    rp2.add(pp3);
    rp2.add(pp4);

    data.add(rule1);
    data.add(rp1);
    data.add(pp1);
    data.add(pp2);
    data.add(alwaysTrue1);
    data.add(alwaysTrue2);

    data.add(rule2);
    data.add(rp2);
    data.add(pp3);
    data.add(pp4);
    data.add(alwaysTrue4);

    StatelessSessionResult sessionResult = session.executeWithResults(data);
    Iterator iter = sessionResult.iterateObjects();

    boolean rp1true = false;
    boolean rp2true = false;
    boolean rp3true = false;
    boolean rp4true = false;
    while (iter.hasNext()) {
      Object o = (Object) iter.next();
      if (o instanceof AlwaysTrue) {
        AlwaysTrue alwaysTrue = (AlwaysTrue) o;
        if (!rp1true) {
          rp1true = alwaysTrue.getCause().equals(pp1);
        }
        if (!rp2true) {
          rp2true = alwaysTrue.getCause().equals(pp2);
        }
        if (!rp3true) {
          rp3true = alwaysTrue.getCause().equals(pp3);
        }
        if (!rp4true) {
          rp4true = alwaysTrue.getCause().equals(pp4);
        }
      }
    }

    assertTrue(rp1true);
    assertTrue(rp2true);
    assertFalse(rp3true);
    assertTrue(rp4true);
  }