Exemple #1
0
  @Before
  public void setUp() {
    instanssi = null;
    instanssiMergeBottomUp = null;
    int aste = 2;
    instanssi2 = new Dkeko(aste);
    instanssi3 = new Dkeko(3);
    instanssi5 = new Dkeko(5);
    instanssi20 = new Dkeko(20);
    solmuarvo = 0;
    solmuarvo1 = 1;
    solmuarvo2 = 2;
    solmu = new Solmu(solmuarvo);
    solmu1 = new Solmu(solmuarvo1);
    solmu2 = new Solmu(solmuarvo2);
    pienin = Integer.MAX_VALUE;
    suurin = 0;
    generator = new Random();

    instanssiT1 = new Dkeko(2);
    instanssiT2 = new Dkeko(5);
    for (int i = 900; i > 400; i--) {
      solmuMerge = new Solmu(i);
      instanssiT2.insert(solmuMerge);
    }
    for (int i = 400; i >= 0; i--) {
      solmuMerge = new Solmu(i);
      instanssiT1.insert(solmuMerge);
    }
  }
Exemple #2
0
 /** Testi Dkeon konstruktorille */
 @Test
 public void testaaKonstruktoriDkekoTest() {
   assertEquals(2, instanssi2.getAste());
   assertEquals(3, instanssi3.getAste());
   assertEquals(5, instanssi5.getAste());
   assertEquals(20, instanssi20.getAste());
 }
Exemple #3
0
 /**
  * Testaa insert() parsmetrina annettu Solmu on null odotettu lopputulos ,keon heapSize ei kasva
  */
 @Test
 public void asetaNullSolmuInsertTest() {
   int heapSize = instanssi5.getHeapSize();
   solmu = null;
   instanssi5.insert(solmu);
   assertEquals(heapSize, instanssi5.getHeapSize());
 }
Exemple #4
0
 /** Testaa DecreaseKey() odotettu lopputulos,keko palauttaa -1, koska keko on tyhja */
 @Test
 public void tyhjaKekoDecreaseKeyTest() {
   assertNull(instanssi5.findMin());
   solmu = new Solmu(3);
   Kekoalkio alkio = new Kekoalkio(solmu);
   assertEquals(-1, instanssi5.decreaseKey(alkio, 2));
 }
Exemple #5
0
 /**
  * Testaa DecreaseKey() odotettu lopputulos,keko palauttaa -1, koska keossa ei ole parametrina
  * annettua solmun arvoa
  */
 @Test
 public void arvoaEiLoydyKekoDecreaseKeyTest() {
   assertNull(instanssi5.findMin());
   solmu = new Solmu(3);
   instanssi5.insert(solmu);
   assertEquals(solmu.getValue(), instanssi5.findMin().getValue());
   Kekoalkio alkio = new Kekoalkio(solmu1);
   assertEquals(-1, instanssi5.decreaseKey(alkio, 0));
 }
Exemple #6
0
 /**
  * Testaa DecreaseKey() odotettu lopputulos,keko palauttaa -1, koska parametrina annettua solmun
  * arvoa yritetaan kasvattaa keossa
  */
 @Test
 public void increaseYritysDecreaseKeyTest() {
   assertNull(instanssi5.findMin());
   solmu = new Solmu(3);
   instanssi5.insert(solmu);
   assertEquals(solmu.getValue(), instanssi5.findMin().getValue());
   Kekoalkio alkio = instanssi5.findKekoalkio(solmu);
   assertEquals(-1, instanssi5.decreaseKey(alkio, 4));
 }
Exemple #7
0
 /** Testaa merge() t1 == null odotettu tulos: palauttaa null */
 @Test
 public void testaaT1NullMergeTest() {
   for (int i = 12; i >= 3; i--) {
     solmu = new Solmu(i);
     instanssi5.insert(solmu);
   }
   instanssi2 = null;
   assertNull(Dkeko.merge(instanssi2, instanssi5));
   assertNull(Dkeko.merge(instanssi5, instanssi2));
 }
Exemple #8
0
  /** Testi MakeHeap() virhetapaus odotettu tulos funktio palauttaa null */
  @Test
  public void asteNotOkMakeHeapTest() {
    instanssi = Dkeko.makeHeap(-2);
    assertEquals(null, instanssi);

    instanssi = Dkeko.makeHeap(7);
    assertEquals(7, instanssi.getAste());

    instanssi = Dkeko.makeHeap(0);
    assertEquals(null, instanssi);
  }
Exemple #9
0
 /**
  * Testaa insert() odotettu lopputulos,kekoon onnistuu useamman kuin haarautumisaste solmun
  * lisääminen solmun arvo valitaan satunnaisesti keko on kekoehdon mukaisesti ehyt lisäyksen
  * jälkeen palauttaa tarkistuksessa oikean minimikeon arvon
  */
 @Test
 public void haarautumisaste20RandomSolmuaInsertTest() {
   assertEquals(solmuNull, instanssi20.getMin());
   for (int i = 0; i < 9260; i++) {
     solmuarvo = generator.nextInt();
     if (pienin > solmuarvo) {
       pienin = solmuarvo;
     }
     solmu = new Solmu(solmuarvo);
     instanssi20.insert(solmu);
     assertEquals(pienin, instanssi20.findMin().getValue());
   }
 }
Exemple #10
0
  /** Testi MakeHeap() perustapaus odotettu tulos funktio palauttaa Dkeko olion */
  @Test
  public void aste2OkMakeHeapTest() {
    instanssi = Dkeko.makeHeap(2);
    assertEquals(2, instanssi.getAste());
    assertEquals(0, instanssi.getHeapSize());
    assertEquals(null, instanssi.getMin());
    assertEquals(null, instanssi.getTail());

    instanssi = Dkeko.makeHeap(20);
    assertEquals(20, instanssi.getAste());
    assertEquals(0, instanssi.getHeapSize());
    assertEquals(null, instanssi.getMin());
    assertEquals(null, instanssi.getTail());
  }
Exemple #11
0
 /**
  * Testaa mergeBottomUp() t1 >== t2 odotettu tulos: palauttaa uuden keko olion, jonka
  * haarautumisaste on sama kuin t2 annetun keon haarautumisaste keot samankokoisia,mutta eri
  * haarautumisaste.suurempi valitaan
  */
 @Test
 public void testaaT1T2YhtasuuriaMergeBottomUpTest() {
   for (int i = 900; i > 400; i--) {
     solmu = new Solmu(i);
     instanssi5.insert(solmu);
   }
   for (int i = 400; i >= 0; i--) {
     solmu = new Solmu(i);
     instanssi2.insert(solmu);
   }
   int summa = instanssi5.getHeapSize() + instanssi2.getHeapSize();
   instanssi = Dkeko.mergeBottomUp(instanssi2, instanssi5);
   assertEquals(0, instanssi.findMin().getValue());
   assertEquals(instanssi5.getAste(), instanssi.getAste());
   assertEquals(summa, instanssi.getHeapSize());
 }
Exemple #12
0
 /**
  * Testaa mergeBottomUp() t1 > t2 odotettu tulos: palauttaa uuden keko olion, jonka keon aste on
  * sama kuin suuremman parametrina annetun keon aste
  */
 @Test
 public void testaaT1SuurempiMergeBottomUpTest() {
   for (int i = 12; i >= 3; i--) {
     solmu = new Solmu(i);
     instanssi5.insert(solmu);
   }
   for (int i = 2; i >= 1; i--) {
     solmu = new Solmu(i);
     instanssi2.insert(solmu);
   }
   int summa = instanssi5.getHeapSize() + instanssi2.getHeapSize();
   instanssi = Dkeko.mergeBottomUp(instanssi5, instanssi2);
   assertEquals(1, instanssi.findMin().getValue());
   assertEquals(instanssi5.getAste(), instanssi.getAste());
   assertEquals(summa, instanssi.getHeapSize());
 }
Exemple #13
0
  /*
   * Testaa merge() ja mergeBottomUp() minimikekojen tulos
   */
  @Test
  public void testaaKekoLopputuloksetBothMergetTest() {
    int summa = instanssiT2.getHeapSize() + instanssiT1.getHeapSize();
    instanssiMergeBottomUp = Dkeko.mergeBottomUp(instanssiT1, instanssiT2);

    instanssiT1 = new Dkeko(2);
    instanssiT2 = new Dkeko(5);
    for (int i = 900; i > 400; i--) {
      solmuMerge = new Solmu(i);
      instanssiT2.insert(solmuMerge);
    }
    for (int i = 400; i >= 0; i--) {
      solmuMerge = new Solmu(i);
      instanssiT1.insert(solmuMerge);
    }
    instanssi = Dkeko.merge(instanssiT1, instanssiT2);

    for (int i = 0; i < instanssi.getHeapSize(); i++) {
      assertEquals(instanssi.deleteMin().getValue(), instanssiMergeBottomUp.deleteMin().getValue());
    }
  }
Exemple #14
0
  /** Testaa findMin odotettu lopputulos ,palauttaa yhden Solmu olion joka pysyy keossa. */
  @Test
  public void yksiSolmuKekoFindMinTest() {
    assertEquals(null, instanssi2.findMin());
    instanssi2.insert(solmu1);
    assertEquals(1, solmu1.getValue());

    assertNotNull(instanssi2.findMin());
    assertEquals(solmu1.getValue(), instanssi2.findMin().getValue());

    assertNotNull(instanssi2.findMin());
    assertEquals(solmu1.getValue(), instanssi2.findMin().getValue());
  }
Exemple #15
0
  /**
   * Testaa insert() odotettu lopputulos,kekoon onnistuu useamman kuin haarautumisaste solmun
   * lisääminen keko on kekoehdon mukaisesti ehyt lisäyksen jälkeen palauttaa tarkistuksessa oikean
   * minimikeon arvon
   */
  @Test
  public void haarautumisaste2ViisiSolmuaInsertTest() {
    assertEquals(solmuNull, instanssi2.getMin());
    assertEquals(2, instanssi2.getAste());
    // isommasta pienempään järjestyksessä
    for (int i = 4; i >= 0; i--) {
      solmu = new Solmu(i);
      instanssi2.insert(solmu);
      assertEquals(solmu.getValue(), instanssi2.findMin().getValue());
    }

    // pienemmästä isompaan solmu järjestyksessä
    instanssi2 = Dkeko.makeHeap(solmuarvo2);
    assertEquals(solmuNull, instanssi2.findMin());
    for (int i = 0; i < 5; i++) {
      solmu = new Solmu(i);
      instanssi2.insert(solmu);
      assertEquals(0, instanssi2.findMin().getValue());
    }
  }
Exemple #16
0
  /**
   * Testaa deleteMin() odotettu lopputulos,keko palauttaa solmu kerrallaan kunnes keko on
   * tyhjä.keon minimisolmun arvo tarkistetaan ennen ja jälkeen deleteMin operaatioita.Sen arvon
   * tulee olla eri ennen ja jälkeen testin
   */
  @Test
  public void aste20RandomDeleteMinTest() {
    assertEquals(solmuNull, instanssi20.getMin());
    for (int i = 0; i < 9260; i++) {
      solmuarvo = generator.nextInt();
      if (pienin > solmuarvo) {
        pienin = solmuarvo;
      }
      solmu = new Solmu(solmuarvo);
      instanssi20.insert(solmu);
      assertEquals(pienin, instanssi20.findMin().getValue());
    }

    while (instanssi20.getHeapSize() != 0) {
      pienin = instanssi20.findMin().getValue();
      assertEquals(pienin, instanssi20.deleteMin().getValue());
      if (instanssi20.getHeapSize() != 0) {
        assertTrue(pienin != instanssi20.findMin().getValue());
      }
    }
  }
Exemple #17
0
  /**
   * Testaa decreaseKey odotettu lopputulos,keossa olevan solmun arvon pienentäminen onnistuu ja
   * solmusta tulee keon pienin alkio
   */
  @Test
  public void aste5RandomDecreaseKeyTest() {
    assertEquals(solmuNull, instanssi5.findMin());
    for (int i = 0; i < 59; i++) {
      solmuarvo = generator.nextInt(Integer.MAX_VALUE);
      if (pienin > solmuarvo) {
        pienin = solmuarvo;
      }
      if (suurin < solmuarvo) {
        suurin = solmuarvo;
      }
      solmu = new Solmu(solmuarvo);
      instanssi5.insert(solmu);
      assertEquals(pienin, instanssi5.findMin().getValue());
    }

    instanssi5.deleteMin();
    assertTrue(pienin != instanssi5.findMin().getValue());
    solmu1.setValue(suurin);
    Kekoalkio alkio = instanssi5.findKekoalkio(solmu1);
    instanssi5.decreaseKey(alkio, pienin);
    assertEquals(pienin, instanssi5.findMin().getValue());
  }
Exemple #18
0
  /**
   * Testaa findMin odotettu lopputulos ,palauttaa yhden Solmu olion arvolla 0,pysyy koko ajan keon
   * pienimpänä joka pysyy keossa.Asetetaan solmut järjestyksessä pienemmästä suurempaan
   */
  @Test
  public void keossa012SolmuSolmuKekoFindMinTest() {
    assertEquals(null, instanssi2.findMin());
    instanssi2.insert(solmu);
    assertEquals(0, solmu.getValue());
    assertNotNull(instanssi2.findMin());
    assertEquals(solmu.getValue(), instanssi2.findMin().getValue());

    instanssi2.insert(solmu1);
    assertEquals(1, solmu1.getValue());
    assertNotNull(instanssi2.findMin());
    assertEquals(solmu.getValue(), instanssi2.findMin().getValue());

    instanssi2.insert(solmu2);
    assertEquals(2, solmu2.getValue());
    assertNotNull(instanssi2.findMin());
    assertEquals(solmu.getValue(), instanssi2.findMin().getValue());

    assertNotNull(instanssi2.findMin());
    assertEquals(solmu.getValue(), instanssi2.findMin().getValue());
  }
Exemple #19
0
 /**
  * Testaa insert() odotettu lopputulos ,kekoon onnistuu yhden solmun lisäys keko on kekoehdon
  * mukaisesti ehyt lisäyksen jälkeen palauttaa tarkistuksessa oikean minimikeon arvon
  */
 @Test
 public void haarautumisaste5YksiSolmuInsertTest() {
   assertEquals(solmuNull, instanssi5.getMin());
   instanssi5.insert(solmu);
   assertEquals(solmu.getValue(), instanssi5.findMin().getValue());
 }
Exemple #20
0
 /** Testaa findMin odotettu lopputulos ,palauttaa null */
 @Test
 public void tyhjaKekoFindMinTest() {
   assertEquals(null, instanssi2.findMin());
   assertEquals(null, instanssi3.findMin());
   assertEquals(null, instanssi5.findMin());
 }
Exemple #21
0
 /** Testaa deleteMin() odotettu lopputulos,keko palauttaa null, koska keko tyhja */
 @Test
 public void tyhjakekodeleteMinTest() {
   assertNull(instanssi2.findMin());
   assertNull(instanssi2.deleteMin());
 }