@Test public final void testTotalBoxedLongBoxedLongBoxedLongBoxedLongBoxedLongMoreBoxedLongs() { final Long[] numbers1 = convertToBoxed(NUMBERS1); final Long[] numbers2 = convertToBoxed(NUMBERS2); for (final Long n1 : numbers1) { for (final Long n2 : numbers2) { for (final Long n3 : numbers1) { for (final Long n4 : numbers2) { for (final Long n5 : numbers1) { @SuppressWarnings("boxing") final Long expected1 = (n1 + n2 + n3 + n4 + n5 + n1 + n2 + n3 + n4 + n5); @SuppressWarnings("boxing") final Long actual1 = total(n1, n2, n3, n4, n5, n1, n2, n3, n4, n5); // System.out.println("expected: " + expected1 + "\nactual: " + actual1); assertThat(actual1, is(equalTo(expected1))); @SuppressWarnings("boxing") final Long expected2 = (n1 + n2 + n3 + n4 + n5 + n1 + n2 + n3 + n4 + n5); @SuppressWarnings("boxing") final Long actual2 = total(n1, n2, n3, n4, n5, n1, n2, n3, n4, n5); // System.out.println("expected: " + expected2 + "\nactual: " + actual2); assertThat(actual2, is(equalTo(expected2))); } } } } } final Long[] numbers3 = new Long[NUMBERS3.length]; System.arraycopy(convertToBoxed(NUMBERS3), 0, numbers3, 0, NUMBERS3.length); final Long[] numbers4 = new Long[NUMBERS4.length]; System.arraycopy(convertToBoxed(NUMBERS4), 0, numbers4, 0, NUMBERS4.length); for (final Long n1 : numbers3) { for (final Long n2 : numbers4) { for (final Long n3 : numbers3) { for (final Long n4 : numbers4) { for (final Long n5 : numbers3) { @SuppressWarnings("boxing") final Long expected3 = (n1 + n2 + n3 + n4 + n5 + n1 + n2 + n3 + n4 + n5); @SuppressWarnings("boxing") final Long actual3 = total(n1, n2, n3, n4, n5, n1, n2, n3, n4, n5); // System.out.println("expected: " + expected3 + "\nactual: " + actual3); assertThat(actual3, is(equalTo(expected3))); @SuppressWarnings("boxing") final Long expected4 = (n1 + n2 + n3 + n4 + n5 + n1 + n2 + n3 + n4 + n5); @SuppressWarnings("boxing") final Long actual4 = total(n1, n2, n3, n4, n5, n1, n2, n3, n4, n5); // System.out.println("expected: " + expected4 + "\nactual: " + actual4); assertThat(actual4, is(equalTo(expected4))); } } } } } }
@Test public final void testSumLongLongLongLongLongLongArray() { final long[] numbers1 = NUMBERS1; final long[] numbers2 = NUMBERS2; for (final long n1 : numbers1) { for (final long n2 : numbers2) { for (final long n3 : numbers1) { for (final long n4 : numbers2) { for (final long n5 : numbers1) { long total1 = n1 + n2 + n3 + n4 + n5; for (final long n : numbers1) total1 += n; @SuppressWarnings("boxing") final Long expected1 = total1; @SuppressWarnings("boxing") final Long actual1 = sum(n1, n2, n3, n4, n5, numbers1); // System.out.println("expected: " + expected1 + "\nactual: " + actual1); assertThat(actual1, is(equalTo(expected1))); long total2 = n1 + n2 + n3 + n4 + n5; for (final long n : numbers2) total2 += n; @SuppressWarnings("boxing") final Long expected2 = total2; @SuppressWarnings("boxing") final Long actual2 = sum(n1, n2, n3, n4, n5, numbers2); // System.out.println("expected: " + expected2 + "\nactual: " + actual2); assertThat(actual2, is(equalTo(expected2))); } } } } } final long[] numbers3 = new long[NUMBERS3.length]; System.arraycopy(NUMBERS3, 0, numbers3, 0, NUMBERS3.length); final long[] numbers4 = new long[NUMBERS4.length]; System.arraycopy(NUMBERS4, 0, numbers4, 0, NUMBERS4.length); for (final long n1 : numbers3) { for (final long n2 : numbers4) { for (final long n3 : numbers3) { for (final long n4 : numbers4) { for (final long n5 : numbers3) { long total3 = n1 + n2 + n3 + n4 + n5; for (final long n : numbers3) total3 += n; @SuppressWarnings("boxing") final Long expected3 = total3; @SuppressWarnings("boxing") final Long actual3 = sum(n1, n2, n3, n4, n5, numbers3); // System.out.println("expected: " + expected3 + "\nactual: " + actual3); assertThat(actual3, is(equalTo(expected3))); long total4 = n1 + n2 + n3 + n4 + n5; for (final long n : numbers4) total4 += n; @SuppressWarnings("boxing") final Long expected4 = total4; @SuppressWarnings("boxing") final Long actual4 = sum(n1, n2, n3, n4, n5, numbers4); // System.out.println("expected: " + expected4 + "\nactual: " + actual4); assertThat(actual4, is(equalTo(expected4))); } } } } } }
@Test public void test_checkMove_Correct() throws GameMoveException { final Dictionary dictionary = createDictionary("abcd", "def", "fefgabcd"); final TilesBank tilesBank = new TilesBank(editor.createTilesBankInfo()); final ScribbleBoard board = new ScribbleBoard( settings, Arrays.asList(player1, player2, player3), tilesBank, dictionary); h1 = board.getPlayerHand(player1); h2 = board.getPlayerHand(player2); h3 = board.getPlayerHand(player3); h1.setTiles(tilesBank.getTiles(0, 3, 6, 9, 12, 15, 18)); // abcdefg h2.setTiles(tilesBank.getTiles(1, 4, 7, 10, 13, 16, 19)); // abcdefg h3.setTiles(tilesBank.getTiles(2, 5, 8, 11, 14, 17, 20)); // abcdefg Personality person = board.getPlayerTurn(); ScribblePlayerHand hand = board.getPlayerHand(person); final Tile[] moveTiles1 = Arrays.copyOf(hand.getTiles(), 4); board.makeTurn(person, new Word(new Position(7, 7), Direction.HORIZONTAL, moveTiles1)); // abcd assertEquals(1, board.getGameMoves().size()); assertEquals(9, tilesBank.getTilesLimit()); assertEquals(7, hand.getTiles().length); assertEquals(10, hand.getPoints()); person = board.getPlayerTurn(); hand = board.getPlayerHand(person); final Tile[] moveTiles2 = new Tile[3]; moveTiles2[0] = moveTiles1[3]; // last 'd' letter System.arraycopy(hand.getTiles(), 4, moveTiles2, 1, 2); board.makeTurn(person, new Word(new Position(7, 10), Direction.HORIZONTAL, moveTiles2)); // def assertEquals(2, board.getGameMoves().size()); assertEquals(7, tilesBank.getTilesLimit()); assertEquals(7, hand.getTiles().length); assertEquals(30, hand.getPoints()); person = board.getPlayerTurn(); hand = board.getPlayerHand(person); final Tile[] moveTiles3 = new Tile[8]; moveTiles3[0] = moveTiles2[2]; // last 'f' letter System.arraycopy(hand.getTiles(), 4, moveTiles3, 1, 3); System.arraycopy(hand.getTiles(), 0, moveTiles3, 4, 4); board.makeTurn( person, new Word(new Position(7, 12), Direction.VERTICAL, moveTiles3)); // fefgabcd assertEquals(3, board.getGameMoves().size()); assertEquals(0, tilesBank.getTilesLimit()); assertEquals(7, hand.getTiles().length); assertEquals(74, hand.getPoints()); // 6 + 5 + 6 + 7*2 + 1 + 2 + 3*2 + 4 +(30-all person) = 74 }
private LogBuffer flipAndPut() { ensureArrayCapacityPlus(bufferForConversions.limit()); System.arraycopy( bufferForConversions.flip().array(), 0, bytes, writeIndex, bufferForConversions.limit()); writeIndex += bufferForConversions.limit(); return this; }
private void ensureArrayCapacityPlus(int plus) { while (writeIndex + plus > bytes.length) { byte[] tmp = bytes; bytes = new byte[bytes.length * 2]; System.arraycopy(tmp, 0, bytes, 0, tmp.length); } }
@Test // Test array sort property that sorted array will contain // all elements in original array public void testArraySameContents() { int[][] arrs = generateRandomArrays(); // loop through all arrays for (int index = 0; index < arrs.length; index++) { int[] testArr = arrs[index]; int[] preSortedArray = new int[testArr.length]; // create copy for comparison System.arraycopy(testArr, 0, preSortedArray, 0, testArr.length); // pass array to Arrays.sort Arrays.sort(testArr); // check that all elements in sorted array are in original array for (int i = 0; i < preSortedArray.length; i++) { if (Arrays.binarySearch(testArr, preSortedArray[i]) < 0) { fail("testArraySameContents"); } } } }
@Test(timeout = TIMEOUT) public void testQuickSort() { DValue[] arrZero = new DValue[0]; Sorting.quickSort(arrZero, new BasicComparator(), new Random()); assertEquals(0, arrZero.length); DValue[] arrOne = new DValue[1]; arrOne[0] = new DValue(4, 0); Sorting.quickSort(arrOne, new BasicComparator(), new Random()); assertEquals(1, arrOne.length); assertEquals(4, arrOne[0].val.intValue()); Random rand = new Random(); HashMap<Integer, Integer> values = new HashMap<Integer, Integer>(); for (int i = 0; i < 50; i++) { int arrlen = rand.nextInt(1000) + 2; DValue[] arrMany = new DValue[arrlen]; DValue[] arrManySorted = new DValue[arrlen]; for (int j = 0; j < arrlen; j++) { arrMany[j] = new DValue(rand.nextInt(200) - 90, 0); if (values.containsKey(arrMany[j].val)) { arrMany[j].count = values.get(arrMany[j].val) + 1; values.put(arrMany[j].val, arrMany[j].count); } else { values.put(arrMany[j].val, 0); } } System.arraycopy(arrMany, 0, arrManySorted, 0, arrlen); Arrays.sort(arrManySorted); Sorting.quickSort(arrMany, new BasicComparator(), new Random()); assertArrayEquals(arrManySorted, arrMany); } }
@Test(timeout = TIMEOUT) public void testRadixSort() { int[] arrZero = new int[0]; arrZero = Sorting.radixSort(arrZero); assertEquals(0, arrZero.length); int[] arrOne = new int[1]; arrOne[0] = 4; arrOne = Sorting.radixSort(arrOne); assertEquals(1, arrOne.length); assertEquals(4, arrOne[0]); Random rand = new Random(); for (int i = 0; i < 50; i++) { int arrlen = rand.nextInt(1000) + 2; int[] arrMany = new int[arrlen]; int[] arrManySorted = new int[arrlen]; for (int j = 0; j < arrlen; j++) { arrMany[j] = rand.nextInt(200) - 90; } System.arraycopy(arrMany, 0, arrManySorted, 0, arrlen); Arrays.sort(arrManySorted); arrMany = Sorting.radixSort(arrMany); assertArrayEquals(arrManySorted, arrMany); } }
@Before public void setUp() throws Exception { arr = new int[] {11, 14, 18, 13, 21, 4}; expected = new int[arr.length]; System.arraycopy(arr, 0, expected, 0, arr.length); Arrays.sort(expected); }
@Override protected void doClientReader() throws Exception { // blocks here final byte[] arraySent = clientQueue.take(); final byte[] arrayReceived = new byte[CAPACITY]; // blocks here final int size = client.receive(arrayReceived, POSITION, LIMIT); assertEquals(size, SIZE); final byte[] dataSent = new byte[SIZE]; final byte[] dataReceived = new byte[SIZE]; System.arraycopy( // arraySent, POSITION, dataSent, 0, SIZE); System.arraycopy( // arrayReceived, POSITION, dataReceived, 0, SIZE); assertTrue(Arrays.equals(dataSent, dataReceived)); }
public byte[] decryptCards(final String password, final byte[] ciphertext) throws Exception { final MessageDigest shaDigest = MessageDigest.getInstance("SHA-1"); byte[] pw1 = password.getBytes("UTF-8"); byte[] keyHash1 = shaDigest.digest(pw1); keyHash1 = shaDigest.digest(keyHash1); byte[] pw2 = new byte[keyHash1.length + pw1.length]; System.arraycopy(keyHash1, 0, pw2, 0, keyHash1.length); System.arraycopy(pw1, 0, pw2, keyHash1.length, pw1.length); byte[] keyHash2 = shaDigest.digest(pw2); keyHash2 = shaDigest.digest(keyHash2); byte[] key = new byte[16]; System.arraycopy(keyHash1, 0, key, 0, key.length); byte[] iv = new byte[16]; System.arraycopy(keyHash1, 16, iv, 0, 4); System.arraycopy(keyHash2, 0, iv, 4, 12); Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding"); cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, "AES"), new IvParameterSpec(iv)); return cipher.doFinal(ciphertext); }
@Test public void test_string_t_length() throws IOException { int string_lenght = this.input.length - 1; // ignore the \0 at the end. byte[] foo = new byte[string_lenght + 4]; // Insert the string length at first 4 positions. Is LittleEndian! foo[0] = (byte) (string_lenght); foo[1] = (byte) (string_lenght >>> 8); foo[2] = (byte) (string_lenght >>> 16); foo[3] = (byte) (string_lenght >>> 24); System.arraycopy(this.input, 0, foo, 4, string_lenght); // ignore the \0 at the end this.binFileReader = new BinFileReader(new BufferedInputStream(new ByteArrayInputStream(foo))); for (String exp : expected_string) { String result = binFileReader.string_t(true); assertEquals("string_t(length=true)", exp, result); assertEquals("string_t(length=true) toString()", exp.toString(), result.toString()); } }
@Test // Test array sort property that array will be the same // size after being passed to the sort method public void testArraySameSize() { int[][] arrs = generateRandomArrays(); // loop through all arrays for (int index = 0; index < arrs.length; index++) { int[] testArr = arrs[index]; int[] preSortedArray = new int[testArr.length]; // create copy for comparison System.arraycopy(testArr, 0, preSortedArray, 0, testArr.length); // pass array to Arrays.sort Arrays.sort(testArr); // check to make sure length has not changed assertEquals(testArr.length, preSortedArray.length); } }
// // verify that the data written to the full blocks are sane // private void checkFile(FileSystem fileSys, Path name, int repl) throws IOException { boolean done = false; // wait till all full blocks are confirmed by the datanodes. while (!done) { try { Thread.sleep(1000); } catch (InterruptedException e) {; } done = true; BlockLocation[] locations = fileSys.getFileBlockLocations(fileSys.getFileStatus(name), 0, AppendTestUtil.FILE_SIZE); if (locations.length < AppendTestUtil.NUM_BLOCKS) { System.out.println("Number of blocks found " + locations.length); done = false; continue; } for (int idx = 0; idx < AppendTestUtil.NUM_BLOCKS; idx++) { if (locations[idx].getHosts().length < repl) { System.out.println("Block index " + idx + " not yet replciated."); done = false; break; } } } byte[] expected = new byte[AppendTestUtil.NUM_BLOCKS * AppendTestUtil.BLOCK_SIZE]; if (simulatedStorage) { for (int i = 0; i < expected.length; i++) { expected[i] = SimulatedFSDataset.DEFAULT_DATABYTE; } } else { System.arraycopy(fileContents, 0, expected, 0, expected.length); } // do a sanity check. Read the file AppendTestUtil.checkFullFile( fileSys, name, AppendTestUtil.NUM_BLOCKS * AppendTestUtil.BLOCK_SIZE, expected, "Read 1"); }
@Test // Test array sort property running it twice on // same input array should always result in same output array public void testArrayPure() { int[][] arrs = generateRandomArrays(); // loop through all arrays for (int index = 0; index < arrs.length; index++) { int[] testArr = arrs[index]; int[] preSortedArray = new int[testArr.length]; // create copy for comparison System.arraycopy(testArr, 0, preSortedArray, 0, testArr.length); // pass array to Arrays.sort Arrays.sort(testArr); // pass copy of array to Arrays.sort Arrays.sort(preSortedArray); // check that output of both sorted arrays are equal assertArrayEquals(preSortedArray, testArr); } }
@Test // Test array sort property that sorted array will not // change after being passed to sort method again public void testArrayIdempotent() { int[][] arrs = generateRandomArrays(); // loop through all arrays for (int index = 0; index < arrs.length; index++) { int[] testArr = arrs[index]; int[] preSortedArray = new int[testArr.length]; // pass array to Arrays.sort Arrays.sort(testArr); // create copy for comparison System.arraycopy(testArr, 0, preSortedArray, 0, testArr.length); // pass sorted array to Arrays.sort again Arrays.sort(testArr); // check to make sure contents have not changed assertArrayEquals(preSortedArray, testArr); } }
public LogBuffer put(byte[] bytes) throws IOException { ensureArrayCapacityPlus(bytes.length); System.arraycopy(bytes, 0, this.bytes, writeIndex, bytes.length); writeIndex += bytes.length; return this; }