TestOwnedEntity.java

package com.nicewuerfel.blockown;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;

public class TestOwnedEntity {

  private static World world1;
  private static World world2;
  private static Entity[] entities;
  private static List<UUID> ids;

  @BeforeClass
  public static void init() {
    world1 = mock(World.class);
    when(world1.getName()).thenReturn("w1");
    world2 = mock(World.class);
    when(world2.getName()).thenReturn("w2");

    Set<UUID> idsSet = new HashSet<>(8);
    for (int i = 0; i < 4; i++) {
      if (!idsSet.add(UUID.randomUUID())) {
        i--;
      }
    }
    ids = new ArrayList<>(4);
    ids.addAll(idsSet);

    entities = new Entity[6];
    entities[0] = createEntity(ids.get(0), world1);
    entities[1] = createEntity(ids.get(0), world1);
    entities[2] = createEntity(ids.get(1), world1);
    entities[3] = createEntity(ids.get(0), world2);
    entities[4] = createEntity(ids.get(2), world2);
    entities[5] = createEntity(ids.get(3), world2);
  }

  private static Entity createEntity(UUID id, World world) {
    Entity entity = mock(Entity.class);
    when(entity.getUniqueId()).thenReturn(id);
    when(entity.getWorld()).thenReturn(world);
    when(entity.getType()).thenReturn(EntityType.BOAT);
    return entity;
  }

  @Rule
  public ExpectedException expected = ExpectedException.none();

  @Test
  public void testFactories() {
    assertEquals(0, OwnedEntity.class.getConstructors().length);

    OwnedEntity.newInstance(entities[0]);
    OwnedEntity.newInstance(ids.get(0), "w1");
    OwnedEntity.newInstance(ids.get(0), "w1", null);

    expected.expect(NullPointerException.class);
    OwnedEntity.newInstance(null);
    OwnedEntity.newInstance(null, "w1");
    OwnedEntity.newInstance(ids.get(0), null);
    OwnedEntity.newInstance(null, null);
    OwnedEntity.newInstance(null, "w1", null);
    OwnedEntity.newInstance(ids.get(0), null, null);
    OwnedEntity.newInstance(null, null, null);
  }

  @Test
  public void testEquals() {
    OwnedEntity[] oe = new OwnedEntity[8];
    oe[0] = OwnedEntity.newInstance(entities[0]);
    oe[1] = OwnedEntity.newInstance(entities[1]);
    oe[2] = OwnedEntity.newInstance(entities[2]);
    oe[3] = OwnedEntity.newInstance(entities[3]);
    oe[4] = OwnedEntity.newInstance(entities[4]);
    oe[5] = OwnedEntity.newInstance(entities[5]);
    oe[6] = OwnedEntity.newInstance(ids.get(0), "w1");
    oe[7] = OwnedEntity.newInstance(ids.get(2), "w1", new Material(EntityType.ARROW));

    // Integrity
    assertFalse(oe[0].equals(oe[2]));
    assertFalse(oe[2].equals(oe[0]));

    // Reflexivity
    assertTrue(oe[0].equals(oe[0]));
    assertTrue(oe[6].equals(oe[6]));
    assertTrue(oe[7].equals(oe[7]));

    // Transitivity
    assertTrue(oe[0].equals(oe[1]));
    assertTrue(oe[1].equals(oe[6]));
    assertTrue(oe[0].equals(oe[6]));

    // Symmetry
    assertTrue(oe[0].equals(oe[1]));
    assertTrue(oe[1].equals(oe[0]));

    assertTrue(oe[0].equals(oe[6]));
    assertTrue(oe[6].equals(oe[0]));

    assertTrue(oe[7].equals(oe[4]));
    assertTrue(oe[4].equals(oe[7]));

    assertFalse(oe[7].equals(oe[5]));
    assertFalse(oe[5].equals(oe[7]));

    // Only UUID is important for equals
    assertTrue(oe[6].equals(oe[3]));
    assertTrue(oe[3].equals(oe[6]));
  }
}