test/org/sourceforge/desert/AbstractParticleEngineTestBase.java

   1 /*
   2  * Copyright (c) 2010 The Desert team
   3  *
   4  * Permission is hereby granted, free of charge, to any person
   5  * obtaining a copy of this software and associated documentation
   6  * files (the "Software"), to deal in the Software without
   7  * restriction, including without limitation the rights to use,
   8  * copy, modify, merge, publish, distribute, sublicense, and/or sell
   9  * copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following
  11  * conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be
  14  * included in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  18  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  20  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23  * OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  */
  26 package org.sourceforge.desert;
  27
  28 import java.awt.Dimension;
  29 import java.util.HashSet;
  30 import java.util.Iterator;
  31 import java.util.Set;
  32 import org.junit.Test;
  33 import static org.junit.Assert.*;
  34
  35 /**
  36  * The tests involving position or speed check inequalities rather than equalities.
  37  * <br>This way, engines don't have to be scientifically correct; if it looks good then it's good enough.
  38  * @author codistmonk (creation 2010-04-17)
  39  */
  40 public abstract class AbstractParticleEngineTestBase {
  41
  42     @Test
  43     public final void testSetBoundsAndAddParticlesThenRemoveAllThenUpdate() {
  44         final ParticleEngine particleEngine = this.createParticleEngine();
  45
  46         particleEngine.setBoardSize(new Dimension());
  47
  48         assertNotNull(particleEngine.getBoardSize());
  49         assertEquals(0, particleEngine.getParticleCount());
  50
  51         particleEngine.addParticle(IMMOBILE_TYPE, 0F, 0F, 0F, 0F);
  52
  53         assertEquals(1, particleEngine.getParticleCount());
  54
  55         particleEngine.addParticle(MOBILE_TYPE_1, 0F, 0F, 0F, 0F);
  56
  57         assertEquals(2, particleEngine.getParticleCount());
  58
  59         particleEngine.removeAllParticles();
  60
  61         assertEquals(0, particleEngine.getParticleCount());
  62         assertNotNull(particleEngine.getBoardSize());
  63
  64         update(particleEngine, SIMULATION_STEP, SIMULATION_STEP);
  65     }
  66
  67     @Test
  68     public final void testImmobileParticleNotMovedByGravity() {
  69         final float x = 2F;
  70         final float y = 3F;
  71         final float deltaTime = 5F;
  72         final ParticleEngine particleEngine = this.createParticleEngine();
  73
  74         particleEngine.setGravity(ParticleEngine.DEFAULT_GRAVITY);
  75         particleEngine.setBoardSize(null);
  76         particleEngine.addParticle(IMMOBILE_TYPE, x, y, 0F, 0F);
  77         update(particleEngine, deltaTime, SIMULATION_STEP);
  78
  79         final Particle particle = particleEngine.iterator().next();
  80
  81         assertEquals(IMMOBILE_TYPE, particle.getType());
  82         assertEquals(x, particle.getX(), DELTA);
  83         assertEquals(y, particle.getY(), DELTA);
  84         assertEquals(0F, particle.getSpeedX(), DELTA);
  85         assertEquals(0F, particle.getSpeedY(), DELTA);
  86     }
  87
  88     @Test
  89     public final void testGravityInitializedToDefault() {
  90         final ParticleEngine particleEngine = this.createParticleEngine();
  91
  92         assertEquals(particleEngine.DEFAULT_GRAVITY, particleEngine.getGravity(), DELTA);
  93     }
  94
  95     @Test
  96     public final void testCountThenSetBoundsThenCountThenRemoveBoundsThenCount() {
  97         final ParticleEngine particleEngine = this.createParticleEngine();
  98
  99         assertEquals(0, particleEngine.getParticleCount());
 100
 101         particleEngine.setBoardSize(new Dimension());
 102
 103         assertEquals(0, particleEngine.getParticleCount());
 104
 105         particleEngine.setBoardSize(null);
 106
 107         assertEquals(0, particleEngine.getParticleCount());
 108     }
 109
 110     @Test
 111     public final void testUpdateWithoutBounds() {
 112         final float x = 0F;
 113         final float y = 2F;
 114         final float speedX = 3F;
 115         final float speedY = 5F;
 116         final float deltaTime = 7F;
 117         final ParticleEngine particleEngine = this.createParticleEngine();
 118
 119         particleEngine.setBoardSize(null);
 120
 121         assertNull("board size should have been null but was " + particleEngine.getBoardSize(), particleEngine.getBoardSize());
 122
 123         particleEngine.setGravity(-0.1F);
 124         particleEngine.addParticle(MOBILE_TYPE_1, x, y, speedX, speedY);
 125         update(particleEngine, deltaTime, SIMULATION_STEP);
 126
 127         final Particle particle = particleEngine.iterator().next();
 128
 129         assertTrue(x + " >= " + particle.getX(), x < particle.getX());
 130         assertTrue(y + " >= " + particle.getY(), y < particle.getY());
 131         // This assertion may not hold when drag is implemented
 132         assertEquals(speedX, particle.getSpeedX(), DELTA);
 133         assertTrue(speedY + " <= " + particle.getSpeedY(), speedY > particle.getSpeedY());
 134     }
 135
 136     @Test
 137     public final void testUpdateWithBottomBound() {
 138         final Integer width = 20;
 139         final Integer height = 10;
 140         final float x = 10F;
 141         final float y = 5F;
 142         final float speedX = 1F;
 143         final float speedY = 5F; // Go downward in screen coordinates
 144         final float deltaTime = 2F;
 145         final ParticleEngine particleEngine = this.createParticleEngine();
 146
 147         particleEngine.setGravity(0F);
 148         particleEngine.setBoardSize(new Dimension(width, height));
 149         particleEngine.addParticle(MOBILE_TYPE_1, x, y, speedX, speedY);
 150         update(particleEngine, deltaTime, SIMULATION_STEP);
 151
 152         final Particle particle = particleEngine.iterator().next();
 153
 154         assertTrue(particle.getY() + " >= " + height, particle.getY() < height);
 155     }
 156
 157     @Test
 158     public final void testUpdateWithTopBound() {
 159         final Integer width = 20;
 160         final Integer height = 10;
 161         final float x = 10F;
 162         final float y = 5F;
 163         final float speedX = 1F;
 164         final float speedY = -5F; // Go upward in screen coordinates
 165         final float deltaTime = 2F;
 166         final ParticleEngine particleEngine = this.createParticleEngine();
 167
 168         particleEngine.setGravity(0F);
 169         particleEngine.setBoardSize(new Dimension(width, height));
 170         particleEngine.addParticle(MOBILE_TYPE_1, x, y, speedX, speedY);
 171         update(particleEngine, deltaTime, SIMULATION_STEP);
 172
 173         final Particle particle = particleEngine.iterator().next();
 174
 175         assertTrue(particle.getY() + " < 0", particle.getY() >= 0);
 176     }
 177
 178     @Test
 179     public final void testUpdateWithLeftBound() {
 180         final Integer width = 20;
 181         final Integer height = 10;
 182         final float x = 10F;
 183         final float y = 4F;
 184         final float speedX = -10F;
 185         final float speedY = 1F;
 186         final float deltaTime = 2F;
 187         final ParticleEngine particleEngine = this.createParticleEngine();
 188
 189         particleEngine.setGravity(0F);
 190         particleEngine.setBoardSize(new Dimension(width, height));
 191         particleEngine.addParticle(MOBILE_TYPE_1, x, y, speedX, speedY);
 192         update(particleEngine, deltaTime, SIMULATION_STEP);
 193
 194         final Particle particle = particleEngine.iterator().next();
 195
 196         assertTrue(particle.getX() + " < 0", particle.getX() >= 0);
 197     }
 198
 199     @Test
 200     public final void testUpdateWithRightBound() {
 201         final Integer width = 20;
 202         final Integer height = 10;
 203         final float x = 10F;
 204         final float y = 4F;
 205         final float speedX = 10F;
 206         final float speedY = 1F;
 207         final float deltaTime = 2F;
 208         final ParticleEngine particleEngine = this.createParticleEngine();
 209
 210         particleEngine.setGravity(0F);
 211         particleEngine.setBoardSize(new Dimension(width, height));
 212         particleEngine.addParticle(MOBILE_TYPE_1, x, y, speedX, speedY);
 213         update(particleEngine, deltaTime, SIMULATION_STEP);
 214
 215         final Particle particle = particleEngine.iterator().next();
 216
 217         assertTrue(particle.getX() + " >= " + width, particle.getX() < width);
 218     }
 219
 220     @Test
 221     public final void testSetThenGetGravity() {
 222         final ParticleEngine particleEngine = this.createParticleEngine();
 223         final float gravity = -42F;
 224
 225         particleEngine.setGravity(gravity);
 226
 227         assertEquals(gravity, particleEngine.getGravity(), DELTA);
 228     }
 229
 230     @Test
 231     public final void testSetThenGetEmptyBoardSize() {
 232         final ParticleEngine particleEngine = this.createParticleEngine();
 233         final Dimension size = new Dimension(0, 0);
 234
 235         particleEngine.setBoardSize(size);
 236
 237         assertEquals(size, particleEngine.getBoardSize());
 238     }
 239
 240     @Test
 241     public final void testSetThenGetNonemptyBoardSize() {
 242         final ParticleEngine particleEngine = this.createParticleEngine();
 243         final Dimension size = new Dimension(640, 480);
 244
 245         particleEngine.setBoardSize(size);
 246
 247         assertEquals(size, particleEngine.getBoardSize());
 248     }
 249
 250     @Test
 251     public final void testAddParticlesAndCountWithoutBounds() {
 252         final ParticleEngine particleEngine = this.createParticleEngine();
 253
 254         particleEngine.setBoardSize(null);
 255
 256         assertEquals(0, particleEngine.getParticleCount());
 257
 258         particleEngine.addParticle(Particle.Type.values()[0], 0F, 0F, 0F, 0F);
 259
 260         assertEquals(1, particleEngine.getParticleCount());
 261
 262         particleEngine.addParticle(Particle.Type.values()[0], 0F, 0F, 0F, 0F);
 263
 264         assertEquals(2, particleEngine.getParticleCount());
 265     }
 266
 267     @Test
 268     public final void testAddParticlesAndCountWithBounds() {
 269         final ParticleEngine particleEngine = this.createParticleEngine();
 270
 271         particleEngine.setBoardSize(new Dimension());
 272
 273         assertEquals(0, particleEngine.getParticleCount());
 274
 275         particleEngine.addParticle(Particle.Type.values()[0], 0F, 0F, 0F, 0F);
 276
 277         assertEquals(1, particleEngine.getParticleCount());
 278
 279         particleEngine.addParticle(Particle.Type.values()[0], 0F, 0F, 0F, 0F);
 280
 281         assertEquals(2, particleEngine.getParticleCount());
 282     }
 283
 284     @Test
 285     public final void testUpdate() {
 286         final ParticleEngine particleEngine = this.createParticleEngine();
 287         final ParticleDefaultImplementation particle1 = new ParticleDefaultImplementation(
 288                 MOBILE_TYPE_1, 2F, 3F, 5F, 7F);
 289         final ParticleDefaultImplementation particle2 = new ParticleDefaultImplementation(
 290                 MOBILE_TYPE_2, 11F, 13F, 17F, 19F);
 291
 292         particleEngine.setGravity(0F);
 293
 294         addParticle(particleEngine, particle1);
 295         addParticle(particleEngine, particle2);
 296
 297         update(particleEngine, 1F, SIMULATION_STEP);
 298
 299         final Iterator<Particle> particleIterator = particleEngine.iterator();
 300
 301         assertTrue(particleIterator.next().getY() > particle1.getY());
 302         assertTrue(particleIterator.next().getY() > particle2.getY());
 303     }
 304
 305     @Test
 306     public final void testIteratorWithoutBounds() {
 307         final ParticleEngine particleEngine = this.createParticleEngine();
 308         final ParticleDefaultImplementation particle1 = new ParticleDefaultImplementation(
 309                 MOBILE_TYPE_1, 2F, 3F, 5F, 7F);
 310         final ParticleDefaultImplementation particle2 = new ParticleDefaultImplementation(
 311                 MOBILE_TYPE_2, 11F, 13F, 17F, 19F);
 312
 313         particleEngine.setBoardSize(null);
 314         addParticle(particleEngine, particle1);
 315         addParticle(particleEngine, particle2);
 316
 317         final Iterator<Particle> particleIterator = particleEngine.iterator();
 318         final Set<Particle> expectedParticles = new HashSet<Particle>();
 319
 320         expectedParticles.add(particle1);
 321         expectedParticles.add(particle2);
 322
 323         for (int i = expectedParticles.size(); i > 0; --i) {
 324             assertTrue("expected at least " + (i + 1) + " particles", particleIterator.hasNext());
 325
 326             final Particle particle = particleIterator.next();
 327
 328             assertTrue("unexpected particle " + particle, expectedParticles.contains(particle));
 329
 330             expectedParticles.remove(particle);
 331         }
 332         assertTrue("missing particles " + expectedParticles, expectedParticles.isEmpty());
 333         assertFalse(particleIterator.hasNext());
 334     }
 335
 336     @Test
 337     public final void testIteratorWithBounds() {
 338         final ParticleEngine particleEngine = this.createParticleEngine();
 339         final ParticleDefaultImplementation particle1 = new ParticleDefaultImplementation(
 340                 MOBILE_TYPE_1, 2F, 3F, 5F, 7F);
 341         final ParticleDefaultImplementation particle2 = new ParticleDefaultImplementation(
 342                 MOBILE_TYPE_2, 11F, 13F, 17F, 19F);
 343
 344         particleEngine.setBoardSize(new Dimension());
 345         addParticle(particleEngine, particle1);
 346         addParticle(particleEngine, particle2);
 347
 348         final Iterator<Particle> particleIterator = particleEngine.iterator();
 349         final Set<Particle> expectedParticles = new HashSet<Particle>();
 350
 351         expectedParticles.add(particle1);
 352         expectedParticles.add(particle2);
 353
 354         for (int i = expectedParticles.size(); i > 0; --i) {
 355             assertTrue("expected at least " + (i + 1) + " particles", particleIterator.hasNext());
 356
 357             final Particle particle = particleIterator.next();
 358
 359             assertTrue("unexpected particle " + particle, expectedParticles.contains(particle));
 360
 361             expectedParticles.remove(particle);
 362         }
 363         assertTrue("missing particles " + expectedParticles, expectedParticles.isEmpty());
 364         assertFalse(particleIterator.hasNext());
 365     }
 366
 367     /**
 368      *
 369      * @return
 370      * <br>A new value
 371      * <br>A non-null value
 372      */
 373     protected abstract ParticleEngine createParticleEngine();
 374
 375     protected static final float DELTA = 1e-12F;
 376
 377     protected static final float SIMULATION_STEP = 1.0F / 60.0F;
 378
 379     protected static final Particle.Type IMMOBILE_TYPE = Particle.Type.IMMOBILE;
 380
 381     protected static final Particle.Type MOBILE_TYPE_1 = Particle.Type.SAND;
 382
 383     protected static final Particle.Type MOBILE_TYPE_2 = Particle.Type.WATER;
 384
 385     /**
 386      *
 387      * @param particleEngine
 388      * <br>Should not be null
 389      * @param particle
 390      * <br>Should not be null
 391      */
 392     protected static final void addParticle(final ParticleEngine particleEngine, final Particle particle) {
 393         particleEngine.addParticle(particle.getType(), particle.getX(), particle.getY(), particle.getSpeedX(), particle.getSpeedY());
 394     }
 395
 396     /**
 397      *
 398      * @param particleEngine
 399      * <br>Should not be null
 400      * @param duration
 401      * <br>Range: <code>[0F .. Float.POSITIVE_INFINITY[</code>
 402      * @param deltaTime
 403      * <br>Range: <code>]0F .. Float.POSITIVE_INFINITY[</code>
 404      */
 405     protected static final void update(final ParticleEngine particleEngine, final float duration, final float deltaTime) {
 406         float time = 0F;
 407
 408         while (time < duration) {
 409             particleEngine.update(deltaTime);
 410
 411             time += deltaTime;
 412         }
 413     }
 414
 415 }