コード例 #1
0
ファイル: Gap.java プロジェクト: triesss/mygithubpage
 /**
  * liefert eine neue Lücke zwischen this und other
  *
  * @param other die zweite Lücke
  * @return eine neue Lücke zwischen this und other null, wenn die Lücken überlappen oder angrenzen
  */
 public Gap between(Gap other) {
   //        if (other.start > this.end) {
   //            return (new Gap(this.end, other.start));
   //        } else {
   //            return null;
   //        }
   if (this.overlaps(other) || this.touches(other)) return null;
   return new Gap(
       this.end < other.getStart() ? this.end : other.end,
       this.start > other.getEnd() ? this.start : other.start);
 }
コード例 #2
0
ファイル: Gap.java プロジェクト: triesss/mygithubpage
 /**
  * prüft, ob this other komplett enthält oder gleich ist
  *
  * @param other Lücke, die möglicherweise enthalten ist
  * @return true, wenn this other komplett enthält oder gleiche Grenzen hat, sonst false
  */
 public boolean contains(Gap other) {
   return (this.end == other.getEnd() || this.contains(other.getEnd()))
       && this.contains(other.getStart());
 }
コード例 #3
0
ファイル: Gap.java プロジェクト: triesss/mygithubpage
  /**
   * Testen der enthaltenen Routinen per Assert Notwendig ist, das Projekt mit "Enable Assertions"
   * zu kompilieren.
   *
   * @param args
   */
  public static void main(String[] args) {
    Gap gap = new Gap(10, 20);

    assert gap.precedes(new Gap(30, 40));
    assert gap.precedes(new Gap(20, 40));
    assert !gap.precedes(new Gap(15, 40));

    assert gap.succeeds(new Gap(0, 5));
    assert gap.succeeds(new Gap(0, 10));
    //        assert gap.succeeds(new Gap(0, 11));
    assert !gap.succeeds(new Gap(0, 11));

    assert gap.touches(new Gap(0, 10));
    assert gap.touches(new Gap(20, 30));
    assert !gap.touches(new Gap(0, 11));
    assert !gap.touches(new Gap(19, 20));
    assert !gap.touches(new Gap(21, 25));

    assert gap.contains(15);
    assert gap.contains(10);
    assert !gap.contains(22);
    assert !gap.contains(20);

    assert gap.contains(new Gap(15, 16));
    assert gap.contains(new Gap(10, 16));
    assert gap.contains(new Gap(15, 20));
    assert !gap.contains(new Gap(9, 15));
    assert !gap.contains(new Gap(15, 21));

    assert gap.overlaps(new Gap(8, 12));
    assert gap.overlaps(new Gap(18, 22));
    assert !gap.overlaps(new Gap(8, 9));
    assert !gap.overlaps(new Gap(22, 25));
    assert !gap.overlaps(new Gap(20, 25));
    assert gap.overlaps(new Gap(8, 25));
    assert gap.overlaps(new Gap(12, 18));

    assert " 10.. 20".equals(gap.toString());
    assert "  0.. 20".equals((new Gap(0, 20)).toString());
    assert "  0..  2".equals((new Gap(0, 2)).toString());
    assert "100..200".equals((new Gap(100, 200)).toString());

    assert gap.equals(new Gap(10, 20));
    assert !gap.equals(new Gap(1, 20));
    Gap testGap = null;
    assert !gap.equals(testGap) : "equals mit null";
    assert !gap.equals("String") : "equals mit falschem Objekttyp";

    assert (new Gap(0, 20)).equals(gap.union(new Gap(0, 10)))
        : "Vereinigung mit links angrenzender Lücke";
    assert gap != gap.union(new Gap(0, 10)) : "Vereinigung muss neues Element zurückgeben";
    assert (new Gap(10, 30)).equals(gap.union(new Gap(20, 30)))
        : "Vereinigung mit rechts angrenzender Lücke";
    assert (new Gap(5, 20)).equals(gap.union(new Gap(5, 15)))
        : "Vereinigung mit links überlappender Lücke";
    assert (new Gap(10, 25)).equals(gap.union(new Gap(15, 25)))
        : "Vereinigung mit rechts überlappender Lücke";
    assert null == (gap.union(new Gap(0, 5))) : "keine Vereinigung unabhängiger Lücken";
    assert null == (gap.union(new Gap(25, 35))) : "keine Vereinigung unabhängiger Lücken";

    assert (new Gap(5, 10)).equals(gap.between(new Gap(0, 5)));
    assert (new Gap(20, 25)).equals(gap.between(new Gap(25, 30)));
    assert null == (gap.between(new Gap(0, 10)));
    assert null == (gap.between(new Gap(20, 30)));
    assert null == (gap.between(new Gap(5, 15)));
    assert null == (gap.between(new Gap(15, 25)));

    assert 0 == gap.compareTo(new Gap(10, 20));
    assert -1 == gap.compareTo(new Gap(30, 40));
    assert -1 == gap.compareTo(new Gap(11, 15));
    assert 1 == gap.compareTo(new Gap(0, 5));
    assert 1 == gap.compareTo(new Gap(5, 10));
    assert 1 == gap.compareTo(new Gap(9, 20));

    // sub: zieht other aus der aktuellen Lücke ab (weil ein Auto abgestellt wird).
    // Ist other gleich this, so wird ein leeres Array zurückgegeben.
    Gap[] sub = gap.sub(new Gap(10, 20));
    assert 0 == sub.length : "sub gleiche Lücke ergibt kein leeres Array";

    // keinerlei Zusammenhang muss Element wie this zurückliefern
    sub = gap.sub(new Gap(0, 5));
    assert 1 == sub.length : "sub ohne Überlagerung darf nur ein Array mit einem Element liefern";
    assert gap.equals(sub[0]) : "sub ohne Überlagerung soll Array mit this zurückliefern";

    sub = gap.sub(new Gap(25, 30));
    assert 1 == sub.length : "sub ohne Überlagerung darf nur ein Array mit einem Element liefern";
    assert gap.equals(sub[0]) : "sub ohne Überlagerung soll Array mit this zurückliefern";

    // Überlappung geht außerhalb der eigenen Lücke -> muss Element wie this zurückliefern
    sub = gap.sub(new Gap(5, 12));
    assert 1 == sub.length : "sub bei Überlappung links darf das Array nur ein Element enthalten";
    assert gap.equals(sub[0]) : "sub bei Überlappung links muss this zurückgeliefert werden";

    sub = gap.sub(new Gap(18, 22));
    assert 1 == sub.length : "sub bei Überlappung rechts darf das Array nur ein Element enthalten";
    assert gap.equals(sub[0]) : "sub bei Überlappung rechts muss this zurückgeliefert werden";

    // Ein Rand stimmt überein -> ein neues Element entsteht
    sub = gap.sub(new Gap(18, 20));
    assert 1 == sub.length : "sub rechter Rand gleich darf nur ein Array mit einem Element liefern";
    assert (new Gap(10, 18)).equals(sub[0]) : "sub mit gleichem rechten Rand";

    sub = gap.sub(new Gap(10, 12));
    assert 1 == sub.length : "sub linker Rand gleich darf nur ein Array mit einem Element liefern";
    assert (new Gap(12, 20)).equals(sub[0]) : "sub mit gleichem linken Rand";

    // mittiges Abziehen -> zwei neue Elemente entstehen
    sub = gap.sub(new Gap(12, 18));
    assert 2 == sub.length : "sub mittig muss Array mit zwei Elementen liefern";
    assert (new Gap(10, 12)).equals(sub[0]) : "sub mittig linkes Element falsch";
    assert (new Gap(18, 20)).equals(sub[1]) : "sub mittig rechtes Element falsch";

    System.out.println("Tests erfolgreich (oder Assertions off)");
  }
コード例 #4
0
ファイル: Gap.java プロジェクト: triesss/mygithubpage
 /**
  * prüft, ob this und other überlappen. Dafür muss this beginnen, bevor other endet und enden,
  * nachdem other startet.
  *
  * @param other Lücke, die möglicherweise überlappt
  * @return true, wenn this und other überlappen
  */
 public boolean overlaps(Gap other) {
   return (this.start < other.getEnd()) && (this.end > other.getStart());
 }