spancalctest.java

OLAP 的客户端代码

   * abe
   * ace
   * ade
   * </pre>
   */
  public void testBug1() {
    Span[][] spans = new Span[4][3];    
    
    spans[0][0] = new Span(a);
    spans[1][0] = new Span(a);
    spans[2][0] = new Span(a);
    spans[3][0] = new Span(a);

    spans[0][1] = new Span(a);
    spans[1][1] = new Span(b);
    spans[2][1] = new Span(c);
    spans[3][1] = new Span(d);

    spans[0][2] = new Span(e);
    spans[1][2] = new Span(e);
    spans[2][2] = new Span(e);
    spans[3][2] = new Span(e);
    
    SpanCalc sc = new SpanCalc(spans);

    SpanConfigSupport scs = new SpanConfigSupport();
    scs.setDefaultDirection(SpanConfig.HIERARCHY_THEN_POSITION_SPAN);
    sc.setConfig(scs);
    sc.initialize();
    checkPlausibility(sc);

    // 4 differnt e's
    check(sc, 0, 2, true, 1, 1);
    check(sc, 1, 2, true, 1, 1);
    check(sc, 2, 2, true, 1, 1);
    check(sc, 3, 2, true, 1, 1);
   
  }



  /**
   * <pre>
   * aa
   * aa
   * </pre>
   */
  public void testMultiSpan1() {
    Span[][] spans = new Span[2][2];
    spans[0][0] = new Span(a);
    spans[1][0] = new Span(a);
    spans[0][1] = new Span(a);
    spans[1][1] = new Span(a);
    SpanCalc sc = new SpanCalc(spans);

    SpanConfigSupport scs = new SpanConfigSupport();
    scs.setDefaultDirection(SpanConfig.HIERARCHY_THEN_POSITION_SPAN);
    sc.setConfig(scs);
    checkPlausibility(sc);
    //toString("testMultiSpan1", sc);

    // all a's are united
    check(sc, 0, 0, true,  2, 2);
    check(sc, 1, 0, false, 0, 0);
    check(sc, 0, 1, false, 0, 0);
    check(sc, 1, 1, false, 0, 0);
   
  }

  /**
   * <pre>
   * aacd
   * aace
   * abcf
   * abcg
   * </pre>
   */
  public SpanCalc createMulti1() {
    Span[][] spans = new Span[4][4];
    spans[0][0] = new Span(a);
    spans[1][0] = new Span(a);
    spans[2][0] = new Span(a);
    spans[3][0] = new Span(a);

    spans[0][1] = new Span(a);
    spans[1][1] = new Span(a);
    spans[2][1] = new Span(b);
    spans[3][1] = new Span(b);

    spans[0][2] = new Span(c);
    spans[1][2] = new Span(c);
    spans[2][2] = new Span(c);
    spans[3][2] = new Span(c);

    spans[0][3] = new Span(d);
    spans[1][3] = new Span(e);
    spans[2][3] = new Span(f);
    spans[3][3] = new Span(g);

    return new SpanCalc(spans);
  }
  


  /**
   * <pre>
   * aacd
   * aace
   * abcf
   * abcg
   * </pre>
   */
  public void testMultiSpan2() {
    SpanCalc sc = createMulti1();

    SpanConfigSupport scs = new SpanConfigSupport();
    scs.setDefaultDirection(SpanConfig.HIERARCHY_THEN_POSITION_SPAN);
    sc.setConfig(scs);
    sc.initialize();
    checkPlausibility(sc);

    // there are two C spans!!
    check(sc, 0, 2, true,  2, 1);
    check(sc, 1, 2, false, 0, 0);
    check(sc, 2, 2, true,  2, 1);
    check(sc, 3, 1, false, 0, 0);
  }

  
  /** --------------------------------------------------------------------- **/  


  static class MySpanCalc extends SpanCalc {
    int counter;
    public MySpanCalc(Axis axis) {
      super(axis);
    }
    public void initialize() {
      ++ counter;
      super.initialize();
    }
  }
  
  public void testInitializer() {
  	Axis axis1 = createAxis1();
    MySpanCalc sc = new MySpanCalc(axis1);
    assertEquals(sc.counter, 0);
    sc.getHierarchyCount();
    sc.getHierarchyCount();
    assertEquals(sc.counter, 1);

    sc = new MySpanCalc(axis1);
    assertEquals(sc.counter, 0);
    sc.getPositionCount();
    sc.getPositionCount();
    assertEquals(sc.counter, 1);
    
    sc = new MySpanCalc(axis1);
    assertEquals(sc.counter, 0);
    sc.getSpan(0,0);
    sc.getSpan(0,0);
    assertEquals(sc.counter, 1);
    
  }
  
  /** --------------------------------------------------------------------- **/  
  class AllEqual implements Displayable {
    public boolean equals(Object o) {
      return o instanceof AllEqual;
    }
    public String getLabel() {
      return this.toString();
    }
    public void accept(Visitor visitor) {
      throw new UnsupportedOperationException();
    }
  }
  
  SpanHeaderFactory allEqualFactory = new SpanHeaderFactory() {
    public Span create(Span span) {
      AllEqual ae = new AllEqual();
      return new Span(span.getAxis(), span.getPosition(), ae);
    }
  };  

  /**
   * <pre>
   * Adds an object O to the hierarchy, that is equal with all its instances.
   * O B0 B0 Y0
   * O B0 B0 Y1
   * O B0 C0 Y0
   * O B0 C0 Y1
   * O B0 C1 Y0
   * O B0 C1 Y1
   * O B0 C2 Y0
   * O B0 C2 Y1
   * O B1 B1 Y0
   * O B1 B1 Y1
   * </pre>
   */
  public void testAddAllEqualToHierarchy() {
  	SpanCalc span2 = new SpanCalc(createAxis2());
    span2.addHierarchyHeader(allEqualFactory, true);
    checkPlausibility(span2);
    assertEquals(4, span2.getHierarchyCount());
  }

  /** --------------------------------------------------------------------- **/  

  /**
   * <pre>
   * H1 B0 B0 H2 Y0
   * H1 B0 B0 H2 Y1
   * H1 B0 C0 H2 Y0
   * H1 B0 C0 H2 Y1
   * H1 B0 C1 H2 Y0
   * H1 B0 C1 H2 Y1
   * H1 B0 C2 H2 Y0
   * H1 B0 C2 H2 Y1
   * H1 B1 B1 H2 Y0
   * H1 B1 B1 H2 Y1
   * </pre>
   */
  public void testAddHierarchiesToHierarchy() {
  	SpanCalc sc = new SpanCalc(createAxis2());
    sc.addHierarchyHeader(new HierarchyHeaderFactory(), true);
    SpanConfigSupport scs = new SpanConfigSupport();
    scs.setDefaultDirection(SpanConfig.POSITION_SPAN);
    sc.setConfig(scs);
    checkPlausibility(sc);

    assertEquals(5, sc.getHierarchyCount());
    assertEquals(10, sc.getPositionCount());

    assertHierarchy(sc, 0, 0);
    assertMember(sc, 0, 1);
    assertMember(sc, 0, 2);
    assertHierarchy(sc, 0, 3);
    assertMember(sc, 0, 4);
    
    // hierarchical spans on positions:
    // H2 is combined into spans of height 2 because of its parents!

    check(sc, 0, 0, true,  10, 1);
    check(sc, 0, 1, true,   8, 1);
    check(sc, 0, 2, true,   2, 1);
    check(sc, 0, 3, true,   2, 1);
    check(sc, 0, 4, true,   1, 1);
  }


  /** --------------------------------------------------------------------- **/  

  /**
   * <pre>
   * L1 B0 B0 B0 L3 Y0
   * L1 B0 B0 B0 L3 Y1
   * L1 B0 L2 C0 L3 Y0
   * L1 B0 L2 C0 L3 Y1
   * L1 B0 L2 C1 L3 Y0
   * L1 B0 L2 C1 L3 Y1
   * L1 B0 L2 C2 L3 Y0
   * L1 B0 L2 C2 L3 Y1
   * L1 B1 B1 B1 L3 Y0
   * L1 B1 B1 B1 L3 Y1
   * </pre>
   */
  public void testAddLevelsToHierarchy() {
  	SpanCalc sc = new SpanCalc(createAxis2());
    sc.addHierarchyHeader(new LevelHeaderFactory(), true);
    SpanConfigSupport scs = new SpanConfigSupport();
    scs.setDefaultDirection(SpanConfig.POSITION_SPAN);
    sc.setConfig(scs);
    checkPlausibility(sc);
    assertEquals(6, sc.getHierarchyCount());
    assertEquals(10, sc.getPositionCount());

    assertLevel(sc, 0, 0);
    assertLevel(sc, 1, 0);
    assertLevel(sc, 1, 4);

    assertMember(sc, 0, 2);
    assertMember(sc, 1, 2);
    assertLevel (sc, 2, 2);
    assertLevel (sc, 3, 2);
    assertLevel (sc, 4, 2);
    assertLevel (sc, 5, 2);
    assertLevel (sc, 6, 2);
    assertLevel (sc, 7, 2);
    assertMember(sc, 8, 2);
    assertMember(sc, 9, 2);

    assertMember(sc, 0, 1);
    assertMember(sc, 1, 1);

    // hierarchical spans on positions:
    // L3 is combined into spans of height 2 because of its parents!
    
    check(sc, 0, 0, true,   10, 1);
    check(sc, 0, 1, true,    8, 1);
    check(sc, 0, 2, true,    2, 1);
    check(sc, 0, 3, true,    2, 1);
    check(sc, 0, 4, true,    2, 1);
    check(sc, 0, 5, true,    1, 1);

    check(sc, 1, 0, false, 0, 0);
    check(sc, 1, 1, false, 0, 0);
    check(sc, 1, 2, false, 0, 0);
    check(sc, 1, 3, false, 0, 0);
    check(sc, 1, 4, false, 0, 0);
    check(sc, 1, 5, true,  1, 1);

    check(sc, 2, 2, true,  6, 1);
    
  }

  /** --------------------------------------------------------------------- **/  

  /**
   * <pre>
   * B  C  Y   (Levels)
   * --------
   * B0 B0 Y0
   * B0 B0 Y1
   * B0 C0 Y0
   * B0 C0 Y1
   * B0 C1 Y0
   * B0 C1 Y1
   * B0 C2 Y0
   * B0 C2 Y1
   * B1 B1 Y0
   * B1 B1 Y1
   * </pre>
   * @author av
   */

  public void testCreatePositionHeader1() {
    SpanCalc sc = new SpanCalc(createAxis2());
    
    SpanCalc h = sc.createPositionHeader(new LevelHeaderFactory());
    checkPlausibility(h);
    assertEquals(1, h.getPositionCount());
    assertEquals(3, h.getHierarchyCount());

    check(h, 0, 0, true,  1, 1);
    check(h, 0, 1, true,  1, 1);
    check(h, 0, 2, true,  1, 1);
    assertEquals("B", ((Level)h.getSpan(0,0).getObject()).getLabel());
    assertEquals("C", ((Level)h.getSpan(0,1).getObject()).getLabel());
    assertEquals("Y", ((Level)h.getSpan(0,2).getObject()).getLabel());
  }

  /**
   * <pre>
   * A  A  X   (Hierarchies)
   * --------
   * B0 B0 Y0
   * B0 B0 Y1
   * B0 C0 Y0
   * B0 C0 Y1
   * B0 C1 Y0
   * B0 C1 Y1
   * B0 C2 Y0
   * B0 C2 Y1
   * B1 B1 Y0
   * B1 B1 Y1
   * </pre>
   * @author av
   */

  public void testCreatePositionHeader2() {
    SpanCalc sc = new SpanCalc(createAxis2());
    
    SpanCalc h = sc.createPositionHeader(new HierarchyHeaderFactory());
    checkPlausibility(h);
    assertEquals(1, h.getPositionCount());
    assertEquals(3, h.getHierarchyCount());

    check(h, 0, 0, true,  1, 1);
    check(h, 0, 1, true,  1, 1);
    check(h, 0, 2, true,  1, 1);
    assertEquals("A", ((Hierarchy)h.getSpan(0,0).getObject()).getLabel());
    assertEquals("A", ((Hierarchy)h.getSpan(0,1).getObject()).getLabel());
    assertEquals("X", ((Hierarchy)h.getSpan(0,2).getObject()).getLabel());
  }
  
  public void toString(String title, SpanCalc sc) {
    PrintWriter pw = new PrintWriter(System.out);
    pw.println("*** " + title + " ***");
    pw.println("objects:");
    printObjects(sc, pw);
    pw.println("spans:");
    printSpans(sc, pw);
    pw.println("breaks");
    printBreaks(sc, pw);
    pw.println("code:");
    printCode(sc, pw);
    //pw.println("-----------------------------------------");
    pw.flush();
  }
  
  void printObjects(SpanCalc sc, PrintWriter out) {
    for (int pi = 0; pi < sc.getPositionCount(); pi++) {
      for (int hi = 0; hi < sc.getHierarchyCount(); hi++) {
        Span s = sc.getSpan(pi, hi);
        out.print(" ");
        out.print(s.getObject().toString());
      }
      out.println();
    }
  }

  void printBreaks(SpanCalc sc, PrintWriter out) {
    for (int pi = 0; pi < sc.getPositionCount(); pi++) {
      for (int hi = 0; hi < sc.getHierarchyCount(); hi++) {
        Span s = sc.getSpan(pi, hi);
        out.print(" ");
        out.print(sc.forcePositionBreak[pi][hi] ? "x" : ".");
      }
      out.println();
    }
  }

  void printCode(SpanCalc sc, PrintWriter out) {
    for (int pi = 0; pi < sc.getPositionCount(); pi++) {
      for (int hi = 0; hi < sc.getHierarchyCount(); hi++) {
        Span s = sc.getSpan(pi, hi);
        out.println("    check(sc, " 
          + s.getPositionIndex() + ", " 
          + s.getHierarchyIndex() + ", " 
          + s.isSignificant() + ", "
          + s.getPositionSpan() + ", "
          + s.getHierarchySpan() + ");");
      }
    }
  }
  
  void printSpans(SpanCalc sc, PrintWriter out) {
    
    char[][] carr = new char[sc.getPositionCount()][sc.getHierarchyCount()];
    char letter = 'a';
    
    for (int pi = 0; pi < sc.getPositionCount(); pi++) {
      for (int hi = 0; hi < sc.getHierarchyCount(); hi++) {
        Span s = sc.getSpan(pi, hi);
        assertEquals(pi, s.getPositionIndex());
        assertEquals(hi, s.getHierarchyIndex());
        if (s.isSignificant()) {
          for (int pspan = 0; pspan < s.getPositionSpan(); pspan++) {
            for (int hspan = 0; hspan < s.getHierarchySpan(); hspan++) {
              carr[pi + pspan][hi + hspan] = letter;
            }
          }
          letter ++;
        }
      }
    }
    
    for (int i = 0; i < carr.length; i++) {
      for (int j = 0; j < carr[i].length; j++)  {
        out.print(" ");
        out.print(carr[i][j]);
      }
      out.println();
    }
    
  }
  
}