Return-Path: X-Original-To: apmail-commons-notifications-archive@minotaur.apache.org Delivered-To: apmail-commons-notifications-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id CECFE18840 for ; Mon, 27 Jul 2015 19:48:56 +0000 (UTC) Received: (qmail 30515 invoked by uid 500); 27 Jul 2015 19:42:13 -0000 Delivered-To: apmail-commons-notifications-archive@commons.apache.org Received: (qmail 30455 invoked by uid 500); 27 Jul 2015 19:42:13 -0000 Mailing-List: contact notifications-help@commons.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@commons.apache.org Delivered-To: mailing list notifications@commons.apache.org Received: (qmail 30220 invoked by uid 99); 27 Jul 2015 19:42:13 -0000 Received: from eris.apache.org (HELO hades.apache.org) (140.211.11.105) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 27 Jul 2015 19:42:13 +0000 Received: from hades.apache.org (localhost [127.0.0.1]) by hades.apache.org (ASF Mail Server at hades.apache.org) with ESMTP id 3489EAC0024 for ; Mon, 27 Jul 2015 19:42:13 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r959803 [32/32] - in /websites/production/commons/content/proper/commons-math: jacoco/ jacoco/org.apache.commons.math3.fraction/ jacoco/org.apache.commons.math3.genetics/ jacoco/org.apache.commons.math3.geometry.euclidean.threed/ jacoco/org... Date: Mon, 27 Jul 2015 19:42:10 -0000 To: notifications@commons.apache.org From: luc@apache.org X-Mailer: svnmailer-1.0.9 Message-Id: <20150727194213.3489EAC0024@hades.apache.org> Modified: websites/production/commons/content/proper/commons-math/xref-test/org/apache/commons/math3/util/ResizableDoubleArrayTest.html ============================================================================== --- websites/production/commons/content/proper/commons-math/xref-test/org/apache/commons/math3/util/ResizableDoubleArrayTest.html (original) +++ websites/production/commons/content/proper/commons-math/xref-test/org/apache/commons/math3/util/ResizableDoubleArrayTest.html Mon Jul 27 19:42:09 2015 @@ -133,477 +133,485 @@ 125 ResizableDoubleArray copyDa = new ResizableDoubleArray(testDa); 126 Assert.assertEquals(copyDa, testDa); 127 Assert.assertEquals(testDa, copyDa); -128 } -129 -130 -131 @Test -132 public void testSetElementArbitraryExpansion1() { -133 -134 // MULTIPLICATIVE_MODE -135 da.addElement(2.0); -136 da.addElement(4.0); -137 da.addElement(6.0); -138 da.setElement(1, 3.0); -139 -140 // Expand the array arbitrarily to 1000 items -141 da.setElement(1000, 3.4); -142 -143 Assert.assertEquals( "The number of elements should now be 1001, it isn't", -144 da.getNumElements(), 1001); -145 -146 Assert.assertEquals( "Uninitialized Elements are default value of 0.0, index 766 wasn't", 0.0, -147 da.getElement( 760 ), Double.MIN_VALUE ); -148 -149 Assert.assertEquals( "The 1000th index should be 3.4, it isn't", 3.4, da.getElement(1000), -150 Double.MIN_VALUE ); -151 Assert.assertEquals( "The 0th index should be 2.0, it isn't", 2.0, da.getElement(0), -152 Double.MIN_VALUE); -153 } -154 -155 @Test -156 public void testSetElementArbitraryExpansion2() { -157 // Make sure numElements and expansion work correctly for expansion boundary cases -158 da.addElement(2.0); -159 da.addElement(4.0); -160 da.addElement(6.0); -161 Assert.assertEquals(16, ((ResizableDoubleArray) da).getCapacity()); -162 Assert.assertEquals(3, da.getNumElements()); -163 da.setElement(3, 7.0); -164 Assert.assertEquals(16, ((ResizableDoubleArray) da).getCapacity()); -165 Assert.assertEquals(4, da.getNumElements()); -166 da.setElement(10, 10.0); -167 Assert.assertEquals(16, ((ResizableDoubleArray) da).getCapacity()); -168 Assert.assertEquals(11, da.getNumElements()); -169 da.setElement(9, 10.0); -170 Assert.assertEquals(16, ((ResizableDoubleArray) da).getCapacity()); -171 Assert.assertEquals(11, da.getNumElements()); -172 -173 try { -174 da.setElement(-2, 3); -175 Assert.fail("Expecting ArrayIndexOutOfBoundsException for negative index"); -176 } catch (ArrayIndexOutOfBoundsException ex) { -177 // expected -178 } -179 -180 // ADDITIVE_MODE -181 -182 ResizableDoubleArray testDa = new ResizableDoubleArray(2, 2.0, 3.0, -183 ResizableDoubleArray.ExpansionMode.ADDITIVE); -184 Assert.assertEquals(2, testDa.getCapacity()); -185 testDa.addElement(1d); -186 testDa.addElement(1d); -187 Assert.assertEquals(2, testDa.getCapacity()); -188 testDa.addElement(1d); -189 Assert.assertEquals(4, testDa.getCapacity()); -190 } -191 -192 @Override -193 @Test -194 public void testAdd1000() { -195 super.testAdd1000(); -196 Assert.assertEquals("Internal Storage length should be 1024 if we started out with initial capacity of " + -197 "16 and an expansion factor of 2.0", -198 1024, ((ResizableDoubleArray) da).getCapacity()); -199 } -200 +128 +129 // JIRA: MATH-1252 +130 final double[] values = {1}; +131 testDa = new ResizableDoubleArray(values); +132 Assert.assertArrayEquals(values, testDa.getElements(), 0); +133 Assert.assertEquals(1, testDa.getNumElements()); +134 Assert.assertEquals(1, testDa.getElement(0), 0); +135 +136 } +137 +138 +139 @Test +140 public void testSetElementArbitraryExpansion1() { +141 +142 // MULTIPLICATIVE_MODE +143 da.addElement(2.0); +144 da.addElement(4.0); +145 da.addElement(6.0); +146 da.setElement(1, 3.0); +147 +148 // Expand the array arbitrarily to 1000 items +149 da.setElement(1000, 3.4); +150 +151 Assert.assertEquals( "The number of elements should now be 1001, it isn't", +152 da.getNumElements(), 1001); +153 +154 Assert.assertEquals( "Uninitialized Elements are default value of 0.0, index 766 wasn't", 0.0, +155 da.getElement( 760 ), Double.MIN_VALUE ); +156 +157 Assert.assertEquals( "The 1000th index should be 3.4, it isn't", 3.4, da.getElement(1000), +158 Double.MIN_VALUE ); +159 Assert.assertEquals( "The 0th index should be 2.0, it isn't", 2.0, da.getElement(0), +160 Double.MIN_VALUE); +161 } +162 +163 @Test +164 public void testSetElementArbitraryExpansion2() { +165 // Make sure numElements and expansion work correctly for expansion boundary cases +166 da.addElement(2.0); +167 da.addElement(4.0); +168 da.addElement(6.0); +169 Assert.assertEquals(16, ((ResizableDoubleArray) da).getCapacity()); +170 Assert.assertEquals(3, da.getNumElements()); +171 da.setElement(3, 7.0); +172 Assert.assertEquals(16, ((ResizableDoubleArray) da).getCapacity()); +173 Assert.assertEquals(4, da.getNumElements()); +174 da.setElement(10, 10.0); +175 Assert.assertEquals(16, ((ResizableDoubleArray) da).getCapacity()); +176 Assert.assertEquals(11, da.getNumElements()); +177 da.setElement(9, 10.0); +178 Assert.assertEquals(16, ((ResizableDoubleArray) da).getCapacity()); +179 Assert.assertEquals(11, da.getNumElements()); +180 +181 try { +182 da.setElement(-2, 3); +183 Assert.fail("Expecting ArrayIndexOutOfBoundsException for negative index"); +184 } catch (ArrayIndexOutOfBoundsException ex) { +185 // expected +186 } +187 +188 // ADDITIVE_MODE +189 +190 ResizableDoubleArray testDa = new ResizableDoubleArray(2, 2.0, 3.0, +191 ResizableDoubleArray.ExpansionMode.ADDITIVE); +192 Assert.assertEquals(2, testDa.getCapacity()); +193 testDa.addElement(1d); +194 testDa.addElement(1d); +195 Assert.assertEquals(2, testDa.getCapacity()); +196 testDa.addElement(1d); +197 Assert.assertEquals(4, testDa.getCapacity()); +198 } +199 +200 @Override 201 @Test -202 public void testAddElements() { -203 ResizableDoubleArray testDa = new ResizableDoubleArray(); -204 -205 // MULTIPLICATIVE_MODE -206 testDa.addElements(new double[] {4, 5, 6}); -207 Assert.assertEquals(3, testDa.getNumElements(), 0); -208 Assert.assertEquals(4, testDa.getElement(0), 0); -209 Assert.assertEquals(5, testDa.getElement(1), 0); -210 Assert.assertEquals(6, testDa.getElement(2), 0); -211 -212 testDa.addElements(new double[] {4, 5, 6}); -213 Assert.assertEquals(6, testDa.getNumElements()); -214 -215 // ADDITIVE_MODE (x's are occupied storage locations, 0's are open) -216 testDa = new ResizableDoubleArray(2, 2.0, 2.5, -217 ResizableDoubleArray.ExpansionMode.ADDITIVE); -218 Assert.assertEquals(2, testDa.getCapacity()); -219 testDa.addElements(new double[] { 1d }); // x,0 -220 testDa.addElements(new double[] { 2d }); // x,x -221 testDa.addElements(new double[] { 3d }); // x,x,x,0 -- expanded -222 Assert.assertEquals(1d, testDa.getElement(0), 0); -223 Assert.assertEquals(2d, testDa.getElement(1), 0); -224 Assert.assertEquals(3d, testDa.getElement(2), 0); -225 Assert.assertEquals(4, testDa.getCapacity()); // x,x,x,0 -226 Assert.assertEquals(3, testDa.getNumElements()); -227 } -228 -229 @Override -230 @Test -231 public void testAddElementRolling() { -232 super.testAddElementRolling(); -233 -234 // MULTIPLICATIVE_MODE -235 da.clear(); -236 da.addElement(1); -237 da.addElement(2); -238 da.addElementRolling(3); -239 Assert.assertEquals(3, da.getElement(1), 0); -240 da.addElementRolling(4); -241 Assert.assertEquals(3, da.getElement(0), 0); -242 Assert.assertEquals(4, da.getElement(1), 0); -243 da.addElement(5); -244 Assert.assertEquals(5, da.getElement(2), 0); -245 da.addElementRolling(6); -246 Assert.assertEquals(4, da.getElement(0), 0); -247 Assert.assertEquals(5, da.getElement(1), 0); -248 Assert.assertEquals(6, da.getElement(2), 0); -249 -250 // ADDITIVE_MODE (x's are occupied storage locations, 0's are open) -251 ResizableDoubleArray testDa = new ResizableDoubleArray(2, 2.0, 2.5, -252 ResizableDoubleArray.ExpansionMode.ADDITIVE); -253 Assert.assertEquals(2, testDa.getCapacity()); -254 testDa.addElement(1d); // x,0 -255 testDa.addElement(2d); // x,x -256 testDa.addElement(3d); // x,x,x,0 -- expanded -257 Assert.assertEquals(1d, testDa.getElement(0), 0); -258 Assert.assertEquals(2d, testDa.getElement(1), 0); -259 Assert.assertEquals(3d, testDa.getElement(2), 0); -260 Assert.assertEquals(4, testDa.getCapacity()); // x,x,x,0 -261 Assert.assertEquals(3, testDa.getNumElements()); -262 testDa.addElementRolling(4d); -263 Assert.assertEquals(2d, testDa.getElement(0), 0); -264 Assert.assertEquals(3d, testDa.getElement(1), 0); -265 Assert.assertEquals(4d, testDa.getElement(2), 0); -266 Assert.assertEquals(4, testDa.getCapacity()); // 0,x,x,x -267 Assert.assertEquals(3, testDa.getNumElements()); -268 testDa.addElementRolling(5d); // 0,0,x,x,x,0 -- time to contract -269 Assert.assertEquals(3d, testDa.getElement(0), 0); -270 Assert.assertEquals(4d, testDa.getElement(1), 0); -271 Assert.assertEquals(5d, testDa.getElement(2), 0); -272 Assert.assertEquals(4, testDa.getCapacity()); // contracted -- x,x,x,0 -273 Assert.assertEquals(3, testDa.getNumElements()); -274 try { -275 testDa.getElement(4); -276 Assert.fail("Expecting ArrayIndexOutOfBoundsException"); -277 } catch (ArrayIndexOutOfBoundsException ex) { -278 // expected -279 } -280 try { -281 testDa.getElement(-1); -282 Assert.fail("Expecting ArrayIndexOutOfBoundsException"); -283 } catch (ArrayIndexOutOfBoundsException ex) { -284 // expected -285 } -286 } -287 -288 @Test -289 public void testSetNumberOfElements() { -290 da.addElement( 1.0 ); -291 da.addElement( 1.0 ); -292 da.addElement( 1.0 ); -293 da.addElement( 1.0 ); -294 da.addElement( 1.0 ); -295 da.addElement( 1.0 ); -296 Assert.assertEquals( "Number of elements should equal 6", da.getNumElements(), 6); -297 -298 ((ResizableDoubleArray) da).setNumElements( 3 ); -299 Assert.assertEquals( "Number of elements should equal 3", da.getNumElements(), 3); -300 -301 try { -302 ((ResizableDoubleArray) da).setNumElements( -3 ); -303 Assert.fail( "Setting number of elements to negative should've thrown an exception"); -304 } catch( IllegalArgumentException iae ) { -305 } -306 -307 ((ResizableDoubleArray) da).setNumElements(1024); -308 Assert.assertEquals( "Number of elements should now be 1024", da.getNumElements(), 1024); -309 Assert.assertEquals( "Element 453 should be a default double", da.getElement( 453 ), 0.0, Double.MIN_VALUE); -310 -311 } -312 -313 @Test -314 public void testWithInitialCapacity() { -315 -316 ResizableDoubleArray eDA2 = new ResizableDoubleArray(2); -317 Assert.assertEquals("Initial number of elements should be 0", 0, eDA2.getNumElements()); +202 public void testAdd1000() { +203 super.testAdd1000(); +204 Assert.assertEquals("Internal Storage length should be 1024 if we started out with initial capacity of " + +205 "16 and an expansion factor of 2.0", +206 1024, ((ResizableDoubleArray) da).getCapacity()); +207 } +208 +209 @Test +210 public void testAddElements() { +211 ResizableDoubleArray testDa = new ResizableDoubleArray(); +212 +213 // MULTIPLICATIVE_MODE +214 testDa.addElements(new double[] {4, 5, 6}); +215 Assert.assertEquals(3, testDa.getNumElements(), 0); +216 Assert.assertEquals(4, testDa.getElement(0), 0); +217 Assert.assertEquals(5, testDa.getElement(1), 0); +218 Assert.assertEquals(6, testDa.getElement(2), 0); +219 +220 testDa.addElements(new double[] {4, 5, 6}); +221 Assert.assertEquals(6, testDa.getNumElements()); +222 +223 // ADDITIVE_MODE (x's are occupied storage locations, 0's are open) +224 testDa = new ResizableDoubleArray(2, 2.0, 2.5, +225 ResizableDoubleArray.ExpansionMode.ADDITIVE); +226 Assert.assertEquals(2, testDa.getCapacity()); +227 testDa.addElements(new double[] { 1d }); // x,0 +228 testDa.addElements(new double[] { 2d }); // x,x +229 testDa.addElements(new double[] { 3d }); // x,x,x,0 -- expanded +230 Assert.assertEquals(1d, testDa.getElement(0), 0); +231 Assert.assertEquals(2d, testDa.getElement(1), 0); +232 Assert.assertEquals(3d, testDa.getElement(2), 0); +233 Assert.assertEquals(4, testDa.getCapacity()); // x,x,x,0 +234 Assert.assertEquals(3, testDa.getNumElements()); +235 } +236 +237 @Override +238 @Test +239 public void testAddElementRolling() { +240 super.testAddElementRolling(); +241 +242 // MULTIPLICATIVE_MODE +243 da.clear(); +244 da.addElement(1); +245 da.addElement(2); +246 da.addElementRolling(3); +247 Assert.assertEquals(3, da.getElement(1), 0); +248 da.addElementRolling(4); +249 Assert.assertEquals(3, da.getElement(0), 0); +250 Assert.assertEquals(4, da.getElement(1), 0); +251 da.addElement(5); +252 Assert.assertEquals(5, da.getElement(2), 0); +253 da.addElementRolling(6); +254 Assert.assertEquals(4, da.getElement(0), 0); +255 Assert.assertEquals(5, da.getElement(1), 0); +256 Assert.assertEquals(6, da.getElement(2), 0); +257 +258 // ADDITIVE_MODE (x's are occupied storage locations, 0's are open) +259 ResizableDoubleArray testDa = new ResizableDoubleArray(2, 2.0, 2.5, +260 ResizableDoubleArray.ExpansionMode.ADDITIVE); +261 Assert.assertEquals(2, testDa.getCapacity()); +262 testDa.addElement(1d); // x,0 +263 testDa.addElement(2d); // x,x +264 testDa.addElement(3d); // x,x,x,0 -- expanded +265 Assert.assertEquals(1d, testDa.getElement(0), 0); +266 Assert.assertEquals(2d, testDa.getElement(1), 0); +267 Assert.assertEquals(3d, testDa.getElement(2), 0); +268 Assert.assertEquals(4, testDa.getCapacity()); // x,x,x,0 +269 Assert.assertEquals(3, testDa.getNumElements()); +270 testDa.addElementRolling(4d); +271 Assert.assertEquals(2d, testDa.getElement(0), 0); +272 Assert.assertEquals(3d, testDa.getElement(1), 0); +273 Assert.assertEquals(4d, testDa.getElement(2), 0); +274 Assert.assertEquals(4, testDa.getCapacity()); // 0,x,x,x +275 Assert.assertEquals(3, testDa.getNumElements()); +276 testDa.addElementRolling(5d); // 0,0,x,x,x,0 -- time to contract +277 Assert.assertEquals(3d, testDa.getElement(0), 0); +278 Assert.assertEquals(4d, testDa.getElement(1), 0); +279 Assert.assertEquals(5d, testDa.getElement(2), 0); +280 Assert.assertEquals(4, testDa.getCapacity()); // contracted -- x,x,x,0 +281 Assert.assertEquals(3, testDa.getNumElements()); +282 try { +283 testDa.getElement(4); +284 Assert.fail("Expecting ArrayIndexOutOfBoundsException"); +285 } catch (ArrayIndexOutOfBoundsException ex) { +286 // expected +287 } +288 try { +289 testDa.getElement(-1); +290 Assert.fail("Expecting ArrayIndexOutOfBoundsException"); +291 } catch (ArrayIndexOutOfBoundsException ex) { +292 // expected +293 } +294 } +295 +296 @Test +297 public void testSetNumberOfElements() { +298 da.addElement( 1.0 ); +299 da.addElement( 1.0 ); +300 da.addElement( 1.0 ); +301 da.addElement( 1.0 ); +302 da.addElement( 1.0 ); +303 da.addElement( 1.0 ); +304 Assert.assertEquals( "Number of elements should equal 6", da.getNumElements(), 6); +305 +306 ((ResizableDoubleArray) da).setNumElements( 3 ); +307 Assert.assertEquals( "Number of elements should equal 3", da.getNumElements(), 3); +308 +309 try { +310 ((ResizableDoubleArray) da).setNumElements( -3 ); +311 Assert.fail( "Setting number of elements to negative should've thrown an exception"); +312 } catch( IllegalArgumentException iae ) { +313 } +314 +315 ((ResizableDoubleArray) da).setNumElements(1024); +316 Assert.assertEquals( "Number of elements should now be 1024", da.getNumElements(), 1024); +317 Assert.assertEquals( "Element 453 should be a default double", da.getElement( 453 ), 0.0, Double.MIN_VALUE); 318 -319 final IntegerDistribution randomData = new UniformIntegerDistribution(100, 1000); -320 final int iterations = randomData.sample(); -321 -322 for( int i = 0; i < iterations; i++) { -323 eDA2.addElement( i ); -324 } -325 -326 Assert.assertEquals("Number of elements should be equal to " + iterations, iterations, eDA2.getNumElements()); -327 -328 eDA2.addElement( 2.0 ); +319 } +320 +321 @Test +322 public void testWithInitialCapacity() { +323 +324 ResizableDoubleArray eDA2 = new ResizableDoubleArray(2); +325 Assert.assertEquals("Initial number of elements should be 0", 0, eDA2.getNumElements()); +326 +327 final IntegerDistribution randomData = new UniformIntegerDistribution(100, 1000); +328 final int iterations = randomData.sample(); 329 -330 Assert.assertEquals("Number of elements should be equals to " + (iterations +1), -331 iterations + 1 , eDA2.getNumElements() ); -332 } +330 for( int i = 0; i < iterations; i++) { +331 eDA2.addElement( i ); +332 } 333 -334 @Test -335 public void testWithInitialCapacityAndExpansionFactor() { -336 -337 ResizableDoubleArray eDA3 = new ResizableDoubleArray(3, 3.0, 3.5); -338 Assert.assertEquals("Initial number of elements should be 0", 0, eDA3.getNumElements() ); -339 -340 final IntegerDistribution randomData = new UniformIntegerDistribution(100, 3000); -341 final int iterations = randomData.sample(); -342 -343 for( int i = 0; i < iterations; i++) { -344 eDA3.addElement( i ); -345 } -346 -347 Assert.assertEquals("Number of elements should be equal to " + iterations, iterations,eDA3.getNumElements()); -348 -349 eDA3.addElement( 2.0 ); +334 Assert.assertEquals("Number of elements should be equal to " + iterations, iterations, eDA2.getNumElements()); +335 +336 eDA2.addElement( 2.0 ); +337 +338 Assert.assertEquals("Number of elements should be equals to " + (iterations +1), +339 iterations + 1 , eDA2.getNumElements() ); +340 } +341 +342 @Test +343 public void testWithInitialCapacityAndExpansionFactor() { +344 +345 ResizableDoubleArray eDA3 = new ResizableDoubleArray(3, 3.0, 3.5); +346 Assert.assertEquals("Initial number of elements should be 0", 0, eDA3.getNumElements() ); +347 +348 final IntegerDistribution randomData = new UniformIntegerDistribution(100, 3000); +349 final int iterations = randomData.sample(); 350 -351 Assert.assertEquals("Number of elements should be equals to " + (iterations +1), -352 iterations +1, eDA3.getNumElements() ); -353 -354 Assert.assertEquals("Expansion factor should equal 3.0", 3.0f, eDA3.getExpansionFactor(), Double.MIN_VALUE); -355 } +351 for( int i = 0; i < iterations; i++) { +352 eDA3.addElement( i ); +353 } +354 +355 Assert.assertEquals("Number of elements should be equal to " + iterations, iterations,eDA3.getNumElements()); 356 -357 @Test -358 public void testDiscard() { -359 da.addElement(2.0); -360 da.addElement(2.0); -361 da.addElement(2.0); -362 da.addElement(2.0); -363 da.addElement(2.0); -364 da.addElement(2.0); -365 da.addElement(2.0); -366 da.addElement(2.0); +357 eDA3.addElement( 2.0 ); +358 +359 Assert.assertEquals("Number of elements should be equals to " + (iterations +1), +360 iterations +1, eDA3.getNumElements() ); +361 +362 Assert.assertEquals("Expansion factor should equal 3.0", 3.0f, eDA3.getExpansionFactor(), Double.MIN_VALUE); +363 } +364 +365 @Test +366 public void testDiscard() { 367 da.addElement(2.0); 368 da.addElement(2.0); 369 da.addElement(2.0); -370 Assert.assertEquals( "Number of elements should be 11", 11, da.getNumElements()); -371 -372 ((ResizableDoubleArray)da).discardFrontElements(5); -373 Assert.assertEquals( "Number of elements should be 6", 6, da.getNumElements()); -374 +370 da.addElement(2.0); +371 da.addElement(2.0); +372 da.addElement(2.0); +373 da.addElement(2.0); +374 da.addElement(2.0); 375 da.addElement(2.0); 376 da.addElement(2.0); 377 da.addElement(2.0); -378 da.addElement(2.0); -379 Assert.assertEquals( "Number of elements should be 10", 10, da.getNumElements()); -380 -381 ((ResizableDoubleArray)da).discardMostRecentElements(2); -382 Assert.assertEquals( "Number of elements should be 8", 8, da.getNumElements()); -383 -384 try { -385 ((ResizableDoubleArray)da).discardFrontElements(-1); -386 Assert.fail( "Trying to discard a negative number of element is not allowed"); -387 } catch( Exception e ){ -388 } -389 -390 try { -391 ((ResizableDoubleArray)da).discardMostRecentElements(-1); -392 Assert.fail( "Trying to discard a negative number of element is not allowed"); -393 } catch( Exception e ){ -394 } -395 -396 try { -397 ((ResizableDoubleArray)da).discardFrontElements( 10000 ); -398 Assert.fail( "You can't discard more elements than the array contains"); -399 } catch( Exception e ){ -400 } -401 -402 try { -403 ((ResizableDoubleArray)da).discardMostRecentElements( 10000 ); -404 Assert.fail( "You can't discard more elements than the array contains"); -405 } catch( Exception e ){ -406 } -407 -408 } +378 Assert.assertEquals( "Number of elements should be 11", 11, da.getNumElements()); +379 +380 ((ResizableDoubleArray)da).discardFrontElements(5); +381 Assert.assertEquals( "Number of elements should be 6", 6, da.getNumElements()); +382 +383 da.addElement(2.0); +384 da.addElement(2.0); +385 da.addElement(2.0); +386 da.addElement(2.0); +387 Assert.assertEquals( "Number of elements should be 10", 10, da.getNumElements()); +388 +389 ((ResizableDoubleArray)da).discardMostRecentElements(2); +390 Assert.assertEquals( "Number of elements should be 8", 8, da.getNumElements()); +391 +392 try { +393 ((ResizableDoubleArray)da).discardFrontElements(-1); +394 Assert.fail( "Trying to discard a negative number of element is not allowed"); +395 } catch( Exception e ){ +396 } +397 +398 try { +399 ((ResizableDoubleArray)da).discardMostRecentElements(-1); +400 Assert.fail( "Trying to discard a negative number of element is not allowed"); +401 } catch( Exception e ){ +402 } +403 +404 try { +405 ((ResizableDoubleArray)da).discardFrontElements( 10000 ); +406 Assert.fail( "You can't discard more elements than the array contains"); +407 } catch( Exception e ){ +408 } 409 -410 @Test -411 public void testSubstitute() { -412 -413 da.addElement(2.0); -414 da.addElement(2.0); -415 da.addElement(2.0); -416 da.addElement(2.0); -417 da.addElement(2.0); -418 da.addElement(2.0); -419 da.addElement(2.0); -420 da.addElement(2.0); +410 try { +411 ((ResizableDoubleArray)da).discardMostRecentElements( 10000 ); +412 Assert.fail( "You can't discard more elements than the array contains"); +413 } catch( Exception e ){ +414 } +415 +416 } +417 +418 @Test +419 public void testSubstitute() { +420 421 da.addElement(2.0); 422 da.addElement(2.0); 423 da.addElement(2.0); -424 Assert.assertEquals( "Number of elements should be 11", 11, da.getNumElements()); -425 -426 ((ResizableDoubleArray)da).substituteMostRecentElement(24); -427 -428 Assert.assertEquals( "Number of elements should be 11", 11, da.getNumElements()); -429 -430 try { -431 ((ResizableDoubleArray)da).discardMostRecentElements(10); -432 } catch( Exception e ){ -433 Assert.fail( "Trying to discard a negative number of element is not allowed"); -434 } +424 da.addElement(2.0); +425 da.addElement(2.0); +426 da.addElement(2.0); +427 da.addElement(2.0); +428 da.addElement(2.0); +429 da.addElement(2.0); +430 da.addElement(2.0); +431 da.addElement(2.0); +432 Assert.assertEquals( "Number of elements should be 11", 11, da.getNumElements()); +433 +434 ((ResizableDoubleArray)da).substituteMostRecentElement(24); 435 -436 ((ResizableDoubleArray)da).substituteMostRecentElement(24); +436 Assert.assertEquals( "Number of elements should be 11", 11, da.getNumElements()); 437 -438 Assert.assertEquals( "Number of elements should be 1", 1, da.getNumElements()); -439 -440 } -441 -442 @Test -443 public void testMutators() { -444 ((ResizableDoubleArray)da).setContractionCriteria(10f); -445 Assert.assertEquals(10f, ((ResizableDoubleArray)da).getContractionCriterion(), 0); -446 ((ResizableDoubleArray)da).setExpansionFactor(8f); -447 Assert.assertEquals(8f, ((ResizableDoubleArray)da).getExpansionFactor(), 0); -448 try { -449 ((ResizableDoubleArray)da).setExpansionFactor(11f); // greater than contractionCriteria -450 Assert.fail("Expecting IllegalArgumentException"); -451 } catch (IllegalArgumentException ex) { -452 // expected -453 } -454 ((ResizableDoubleArray)da).setExpansionMode( -455 ResizableDoubleArray.ADDITIVE_MODE); -456 Assert.assertEquals(ResizableDoubleArray.ADDITIVE_MODE, -457 ((ResizableDoubleArray)da).getExpansionMode()); -458 try { -459 ((ResizableDoubleArray)da).setExpansionMode(-1); -460 Assert.fail("Expecting IllegalArgumentException"); -461 } catch (IllegalArgumentException ex) { -462 // expected -463 } -464 } -465 -466 @Test -467 public void testEqualsAndHashCode() throws Exception { -468 -469 // Wrong type -470 ResizableDoubleArray first = new ResizableDoubleArray(); -471 Double other = new Double(2); -472 Assert.assertFalse(first.equals(other)); +438 try { +439 ((ResizableDoubleArray)da).discardMostRecentElements(10); +440 } catch( Exception e ){ +441 Assert.fail( "Trying to discard a negative number of element is not allowed"); +442 } +443 +444 ((ResizableDoubleArray)da).substituteMostRecentElement(24); +445 +446 Assert.assertEquals( "Number of elements should be 1", 1, da.getNumElements()); +447 +448 } +449 +450 @Test +451 public void testMutators() { +452 ((ResizableDoubleArray)da).setContractionCriteria(10f); +453 Assert.assertEquals(10f, ((ResizableDoubleArray)da).getContractionCriterion(), 0); +454 ((ResizableDoubleArray)da).setExpansionFactor(8f); +455 Assert.assertEquals(8f, ((ResizableDoubleArray)da).getExpansionFactor(), 0); +456 try { +457 ((ResizableDoubleArray)da).setExpansionFactor(11f); // greater than contractionCriteria +458 Assert.fail("Expecting IllegalArgumentException"); +459 } catch (IllegalArgumentException ex) { +460 // expected +461 } +462 ((ResizableDoubleArray)da).setExpansionMode( +463 ResizableDoubleArray.ADDITIVE_MODE); +464 Assert.assertEquals(ResizableDoubleArray.ADDITIVE_MODE, +465 ((ResizableDoubleArray)da).getExpansionMode()); +466 try { +467 ((ResizableDoubleArray)da).setExpansionMode(-1); +468 Assert.fail("Expecting IllegalArgumentException"); +469 } catch (IllegalArgumentException ex) { +470 // expected +471 } +472 } 473 -474 // Null -475 other = null; -476 Assert.assertFalse(first.equals(other)); -477 -478 // Reflexive -479 Assert.assertTrue(first.equals(first)); -480 -481 // Argumentless constructor -482 ResizableDoubleArray second = new ResizableDoubleArray(); -483 verifyEquality(first, second); -484 -485 // Equals iff same data, same properties -486 ResizableDoubleArray third = new ResizableDoubleArray(3, 2.0, 2.0); -487 verifyInequality(third, first); -488 ResizableDoubleArray fourth = new ResizableDoubleArray(3, 2.0, 2.0); -489 ResizableDoubleArray fifth = new ResizableDoubleArray(2, 2.0, 2.0); -490 verifyEquality(third, fourth); -491 verifyInequality(third, fifth); -492 third.addElement(4.1); -493 third.addElement(4.2); -494 third.addElement(4.3); -495 fourth.addElement(4.1); -496 fourth.addElement(4.2); -497 fourth.addElement(4.3); +474 @Test +475 public void testEqualsAndHashCode() throws Exception { +476 +477 // Wrong type +478 ResizableDoubleArray first = new ResizableDoubleArray(); +479 Double other = new Double(2); +480 Assert.assertFalse(first.equals(other)); +481 +482 // Null +483 other = null; +484 Assert.assertFalse(first.equals(other)); +485 +486 // Reflexive +487 Assert.assertTrue(first.equals(first)); +488 +489 // Argumentless constructor +490 ResizableDoubleArray second = new ResizableDoubleArray(); +491 verifyEquality(first, second); +492 +493 // Equals iff same data, same properties +494 ResizableDoubleArray third = new ResizableDoubleArray(3, 2.0, 2.0); +495 verifyInequality(third, first); +496 ResizableDoubleArray fourth = new ResizableDoubleArray(3, 2.0, 2.0); +497 ResizableDoubleArray fifth = new ResizableDoubleArray(2, 2.0, 2.0); 498 verifyEquality(third, fourth); -499 -500 // expand -501 fourth.addElement(4.4); -502 verifyInequality(third, fourth); -503 third.addElement(4.4); -504 verifyEquality(third, fourth); -505 fourth.addElement(4.4); -506 verifyInequality(third, fourth); -507 third.addElement(4.4); -508 verifyEquality(third, fourth); -509 fourth.addElementRolling(4.5); -510 third.addElementRolling(4.5); -511 verifyEquality(third, fourth); -512 -513 // discard -514 third.discardFrontElements(1); -515 verifyInequality(third, fourth); -516 fourth.discardFrontElements(1); -517 verifyEquality(third, fourth); -518 -519 // discard recent -520 third.discardMostRecentElements(2); -521 fourth.discardMostRecentElements(2); -522 verifyEquality(third, fourth); -523 -524 // wrong order -525 third.addElement(18); -526 fourth.addElement(17); -527 third.addElement(17); -528 fourth.addElement(18); -529 verifyInequality(third, fourth); -530 -531 // copy -532 ResizableDoubleArray.copy(fourth, fifth); -533 verifyEquality(fourth, fifth); -534 -535 // Copy constructor -536 verifyEquality(fourth, new ResizableDoubleArray(fourth)); -537 -538 // Instance copy -539 verifyEquality(fourth, fourth.copy()); -540 -541 } +499 verifyInequality(third, fifth); +500 third.addElement(4.1); +501 third.addElement(4.2); +502 third.addElement(4.3); +503 fourth.addElement(4.1); +504 fourth.addElement(4.2); +505 fourth.addElement(4.3); +506 verifyEquality(third, fourth); +507 +508 // expand +509 fourth.addElement(4.4); +510 verifyInequality(third, fourth); +511 third.addElement(4.4); +512 verifyEquality(third, fourth); +513 fourth.addElement(4.4); +514 verifyInequality(third, fourth); +515 third.addElement(4.4); +516 verifyEquality(third, fourth); +517 fourth.addElementRolling(4.5); +518 third.addElementRolling(4.5); +519 verifyEquality(third, fourth); +520 +521 // discard +522 third.discardFrontElements(1); +523 verifyInequality(third, fourth); +524 fourth.discardFrontElements(1); +525 verifyEquality(third, fourth); +526 +527 // discard recent +528 third.discardMostRecentElements(2); +529 fourth.discardMostRecentElements(2); [... 135 lines stripped ...]