/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
|
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
|
* add the following below this CDDL HEADER, with the fields enclosed
|
* by brackets "[]" replaced with your own identifying information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Copyright 2006-2009 Sun Microsystems, Inc.
|
* Portions Copyright 2011 ForgeRock AS
|
*/
|
package org.opends.server.util;
|
|
import java.io.BufferedReader;
|
import java.io.BufferedWriter;
|
import java.io.File;
|
import java.io.FileReader;
|
import java.io.FileWriter;
|
import java.io.IOException;
|
import java.io.PrintWriter;
|
import java.io.RandomAccessFile;
|
import java.nio.ByteBuffer;
|
import java.nio.channels.FileChannel;
|
import java.nio.channels.FileLock;
|
import java.text.ParseException;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.LinkedList;
|
import java.util.List;
|
|
import org.opends.server.TestCaseUtils;
|
import org.opends.server.types.ByteString;
|
import org.opends.server.types.ByteSequence;
|
import org.testng.Assert;
|
import org.testng.annotations.BeforeClass;
|
import org.testng.annotations.DataProvider;
|
import org.testng.annotations.Test;
|
|
/**
|
* This class defines a set of tests for the
|
* {@link org.opends.server.util.StaticUtils} class.
|
*/
|
public final class TestStaticUtils extends UtilTestCase {
|
// Lower case hex digit lookup table.
|
private static final char[] HEX_DIGITS_LOWER = new char[] { '0', '1',
|
'2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
|
|
// Upper case hex digit lookup table.
|
private static final char[] HEX_DIGITS_UPPER = new char[] { '0', '1',
|
'2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
|
|
// Lookup table for 8-bit strings.
|
private static final String[] BIT_STRINGS = new String[256];
|
static {
|
final char[] ZEROS = new char[] { '0', '0', '0', '0', '0', '0', '0',
|
'0' };
|
|
for (int i = 0; i < 256; i++) {
|
String bits = Integer.toBinaryString(i);
|
StringBuilder sb = new StringBuilder(8);
|
sb.append(ZEROS, 0, 8 - bits.length());
|
sb.append(bits);
|
BIT_STRINGS[i] = sb.toString();
|
}
|
}
|
|
/**
|
* Once-only initialization.
|
*
|
* @throws Exception
|
* If an unexpected error occurred.
|
*/
|
@BeforeClass
|
public void setUp() throws Exception {
|
}
|
|
/**
|
* Create test strings for the {@link StaticUtils#getBytes(String)}.
|
*
|
* @return Returns an array of test strings.
|
*/
|
@DataProvider(name = "getBytesTestData")
|
public Object[][] createGetBytesTestData() {
|
List<String> strings = new LinkedList<String>();
|
|
// Some simple strings.
|
strings.add("");
|
strings.add(" ");
|
strings.add("an ascii string");
|
|
// A string containing just UTF-8 1 byte sequences.
|
StringBuilder builder = new StringBuilder();
|
for (char c = '\u0000'; c < '\u0080'; c++) {
|
builder.append(c);
|
}
|
strings.add(builder.toString());
|
|
// A string containing UTF-8 1 and 2 byte sequences.
|
builder = new StringBuilder();
|
for (char c = '\u0000'; c < '\u0100'; c++) {
|
builder.append(c);
|
}
|
strings.add(builder.toString());
|
|
// A string containing UTF-8 1 and 6 byte sequences.
|
builder = new StringBuilder();
|
for (char c = '\u0000'; c < '\u0080'; c++) {
|
builder.append(c);
|
}
|
for (char c = '\uff00'; c != '\u0000'; c++) {
|
builder.append(c);
|
}
|
strings.add(builder.toString());
|
|
// Construct the array.
|
Object[][] data = new Object[strings.size()][];
|
for (int i = 0; i < strings.size(); i++) {
|
data[i] = new Object[] { strings.get(i) };
|
}
|
|
return data;
|
}
|
|
/**
|
* Tests the {@link StaticUtils#decodeUTF8(byte[])} method.
|
*
|
* @param inputString
|
* The input string.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "getBytesTestData")
|
public void testDecodeUTF8(String inputString) throws Exception
|
{
|
final byte[] bytes = inputString.getBytes("UTF-8");
|
Assert.assertEquals(StaticUtils.decodeUTF8(bytes), inputString);
|
}
|
|
/**
|
* Tests the {@link StaticUtils#getBytes(String)} method.
|
*
|
* @param inputString
|
* The input string.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "getBytesTestData")
|
public void testGetBytes(String inputString) throws Exception {
|
Assert.assertEquals(StaticUtils.getBytes(inputString), inputString
|
.getBytes("UTF-8"));
|
}
|
|
/**
|
* Tests the {@link StaticUtils#getBytes(char[])} method.
|
*
|
* @param inputString
|
* The input string.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "getBytesTestData")
|
public void testCharsToBytes(String inputString) throws Exception {
|
Assert.assertEquals(StaticUtils.getBytes(inputString.toCharArray()),
|
inputString.getBytes("UTF-8"));
|
}
|
|
/**
|
* Create test strings for the {@link StaticUtils#byteToHex(byte)}.
|
*
|
* @return Returns an array of test strings.
|
*/
|
@DataProvider(name = "byteToHexTestData")
|
public Object[][] createByteToHexTestData() {
|
Object[][] data = new Object[256][];
|
|
for (int i = 0; i < 256; i++) {
|
data[i] = new Object[] { new Byte((byte) i) };
|
}
|
|
return data;
|
}
|
|
/**
|
* Tests the {@link StaticUtils#byteToHex(byte)} method.
|
*
|
* @param b
|
* The input byte.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "byteToHexTestData")
|
public void testByteToHex(byte b) throws Exception {
|
char[] chars = new char[] { HEX_DIGITS_UPPER[(b & 0xf0) >> 4],
|
HEX_DIGITS_UPPER[b & 0x0f] };
|
|
String hex = new String(chars);
|
|
Assert.assertEquals(StaticUtils.byteToHex(b), hex);
|
}
|
|
/**
|
* Tests the {@link StaticUtils#byteToLowerHex(byte)} method.
|
*
|
* @param b
|
* The input byte.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "byteToHexTestData")
|
public void testByteToLowerHex(byte b) throws Exception {
|
char[] chars = new char[] { HEX_DIGITS_LOWER[(b & 0xf0) >> 4],
|
HEX_DIGITS_LOWER[b & 0x0f] };
|
|
String hex = new String(chars);
|
|
Assert.assertEquals(StaticUtils.byteToLowerHex(b), hex);
|
}
|
|
/**
|
* Tests the {@link StaticUtils#byteToASCII(byte)} method.
|
*
|
* @param b
|
* The input byte.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "byteToHexTestData")
|
public void testByteToASCII(byte b) throws Exception {
|
if (b < 32 || b > 126) {
|
Assert.assertEquals(StaticUtils.byteToASCII(b), ' ');
|
} else {
|
Assert.assertEquals(StaticUtils.byteToASCII(b), (char) b);
|
}
|
}
|
|
/**
|
* Create test strings for the {@link StaticUtils#bytesToHex(byte[])}.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "bytesToHexTestData")
|
public Object[][] createBytesToHexTestData() {
|
return new Object[][] {
|
{ null, "" },
|
{ new byte[0], "" },
|
{ new byte[] { 0x00 }, "00" },
|
{ new byte[] { 0x00, 0x7f, (byte) 0x80, (byte) 0xff },
|
"00 7F 80 FF" } };
|
}
|
|
/**
|
* Tests the {@link StaticUtils#bytesToHex(byte[])} method.
|
*
|
* @param bytes
|
* The input byte array.
|
* @param expected
|
* The expected result.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "bytesToHexTestData")
|
public void testBytesToHex(byte[] bytes, String expected)
|
throws Exception {
|
Assert.assertEquals(StaticUtils.bytesToHex(bytes), expected);
|
}
|
|
/**
|
* Tests the {@link StaticUtils#bytesToHex(java.nio.ByteBuffer)}
|
* method.
|
*
|
* @param bytes
|
* The input byte array.
|
* @param expected
|
* The expected result.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "bytesToHexTestData")
|
public void testBytesToHexByteBuffer(byte[] bytes, String expected)
|
throws Exception {
|
ByteBuffer buffer = (bytes != null) ? ByteBuffer.wrap(bytes) : null;
|
|
Assert.assertEquals(StaticUtils.bytesToHex(buffer), expected);
|
}
|
|
/**
|
* Tests the {@link StaticUtils#byteToBinary(byte)} method.
|
*
|
* @param b
|
* The input byte.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "byteToHexTestData")
|
public void testByteToBinary(byte b) throws Exception {
|
Assert.assertEquals(StaticUtils.byteToBinary(b), BIT_STRINGS[b & 0xff]);
|
}
|
|
/**
|
* Create test data for {@link StaticUtils#compare(byte[], byte[])}.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "compareBytesTestData")
|
public Object[][] createCompareBytesTestData() {
|
return new Object[][] {
|
{ null, null, 0 },
|
{ null, new byte[0], -1 },
|
{ new byte[0], null, 1 },
|
{ new byte[0], new byte[0], 0 },
|
{ new byte[] { 0x00 }, new byte[] { 0x00 }, 0 },
|
{ new byte[] { 0x01 }, new byte[] { 0x00 }, 1 },
|
{ new byte[] { 0x7f }, new byte[] { 0x00 }, 1 },
|
{ new byte[] { (byte) 0x80 }, new byte[] { 0x00 }, 1 },
|
{ new byte[] { (byte) 0xff }, new byte[] { 0x00 }, 1 },
|
{ new byte[] { 0x00 }, new byte[] { 0x01 }, -1 },
|
{ new byte[] { 0x00 }, new byte[] { 0x7f }, -1 },
|
{ new byte[] { 0x00 }, new byte[] { (byte) 0x80 }, -1 },
|
{ new byte[] { 0x00 }, new byte[] { (byte) 0xff }, -1 },
|
{ new byte[] { 0x00, 0x01, 0x02 },
|
new byte[] { 0x00, 0x01, 0x02 }, 0 },
|
{ new byte[] { 0x00, 0x01 }, new byte[] { 0x00, 0x01, 0x02 },
|
-1 },
|
{ new byte[] { 0x00, 0x01, 0x02 }, new byte[] { 0x00, 0x01 },
|
1 }, };
|
}
|
|
/**
|
* Tests the {@link StaticUtils#compare(byte[], byte[])} method.
|
*
|
* @param a
|
* The first byte array.
|
* @param a2
|
* The second byte array.
|
* @param expected
|
* The expected result.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "compareBytesTestData")
|
public void testCompareBytes(byte[] a, byte[] a2, int expected)
|
throws Exception {
|
int rc = StaticUtils.compare(a, a2);
|
|
if (expected < 0 && rc >= 0) {
|
Assert.fail("Expected negative result but got " + rc);
|
}
|
|
if (expected > 0 && rc <= 0) {
|
Assert.fail("Expected positive result but got " + rc);
|
}
|
|
if (expected == 0 && rc != 0) {
|
Assert.fail("Expected zero result but got " + rc);
|
}
|
}
|
|
/**
|
* Create test strings for the {@link StaticUtils#isDigit(char)}.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "isDigitTestData")
|
public Object[][] createIsDigitTestData() {
|
List<Object[]> data = new LinkedList<Object[]>();
|
|
for (char c = '0'; c <= '9'; c++) {
|
data.add(new Object[] { c, true });
|
}
|
|
data.add(new Object[] { ' ', false });
|
data.add(new Object[] { (char) ('0' - 1), false });
|
data.add(new Object[] { (char) ('9' + 1), false });
|
data.add(new Object[] { '\uFF10', false });
|
|
return data.toArray(new Object[2][]);
|
}
|
|
/**
|
* Tests the {@link StaticUtils#isDigit(char)} method.
|
*
|
* @param c
|
* The test char.
|
* @param result
|
* The expected result.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "isDigitTestData")
|
public void testIsDigit(char c, boolean result) throws Exception {
|
Assert.assertEquals(StaticUtils.isDigit(c), result);
|
}
|
|
/**
|
* Create test strings for the {@link StaticUtils#isAlpha(char)}.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "isAlphaTestData")
|
public Object[][] createIsAlphaTestData() {
|
List<Object[]> data = new LinkedList<Object[]>();
|
|
for (char c = 'a'; c <= 'z'; c++) {
|
data.add(new Object[] { c, true });
|
}
|
|
for (char c = 'A'; c <= 'Z'; c++) {
|
data.add(new Object[] { c, true });
|
}
|
|
for (char c = '0'; c <= '9'; c++) {
|
data.add(new Object[] { c, false });
|
}
|
|
data.add(new Object[] { ' ', false });
|
data.add(new Object[] { (char) ('a' - 1), false });
|
data.add(new Object[] { (char) ('z' + 1), false });
|
data.add(new Object[] { (char) ('A' - 1), false });
|
data.add(new Object[] { (char) ('Z' + 1), false });
|
data.add(new Object[] { '\u00D9', false });
|
|
return data.toArray(new Object[2][]);
|
}
|
|
/**
|
* Tests the {@link StaticUtils#isAlpha(char)} method.
|
*
|
* @param c
|
* The test char.
|
* @param result
|
* The expected result.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "isAlphaTestData")
|
public void testIsAlpha(char c, boolean result) throws Exception {
|
Assert.assertEquals(StaticUtils.isAlpha(c), result);
|
}
|
|
/**
|
* Create test strings for the {@link StaticUtils#isHexDigit(char)}.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "isHexDigitTestData")
|
public Object[][] createIsHexDigitTestData() {
|
List<Object[]> data = new LinkedList<Object[]>();
|
|
for (char c = 'a'; c <= 'f'; c++) {
|
data.add(new Object[] { c, true });
|
}
|
|
for (char c = 'A'; c <= 'F'; c++) {
|
data.add(new Object[] { c, true });
|
}
|
|
for (char c = '0'; c <= '9'; c++) {
|
data.add(new Object[] { c, true });
|
}
|
|
data.add(new Object[] { ' ', false });
|
data.add(new Object[] { (char) ('0' - 1), false });
|
data.add(new Object[] { (char) ('9' + 1), false });
|
data.add(new Object[] { (char) ('a' - 1), false });
|
data.add(new Object[] { (char) ('f' + 1), false });
|
data.add(new Object[] { (char) ('A' - 1), false });
|
data.add(new Object[] { (char) ('F' + 1), false });
|
data.add(new Object[] { '\u00D9', false });
|
|
return data.toArray(new Object[2][]);
|
}
|
|
/**
|
* Tests the {@link StaticUtils#isHexDigit(char)} method.
|
*
|
* @param c
|
* The test char.
|
* @param result
|
* The expected result.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "isHexDigitTestData")
|
public void testIsHexDigit(char c, boolean result) throws Exception {
|
Assert.assertEquals(StaticUtils.isHexDigit(c), result);
|
}
|
|
/**
|
* Create invalid test strings for the
|
* {@link StaticUtils#hexStringToByteArray(String)}.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "hexStringToByteArrayInvalidTestData")
|
public Object[][] createHexStringToByteArrayInvalidTestData() {
|
return new Object[][] { { "a" }, { "aaa" }, { "0/" }, { "0:" },
|
{ "0@" }, { "0G" }, { "0`" }, { "0g" } };
|
}
|
|
/**
|
* Tests the {@link StaticUtils#hexStringToByteArray(String)} method.
|
*
|
* @param hexString
|
* The test string.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = ParseException.class, dataProvider = "hexStringToByteArrayInvalidTestData")
|
public void testHexStringToByteArrayException(String hexString)
|
throws Exception {
|
StaticUtils.hexStringToByteArray(hexString);
|
}
|
|
/**
|
* Create test strings for the
|
* {@link StaticUtils#hexStringToByteArray(String)}.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "hexStringToByteArrayTestData")
|
public Object[][] createHexStringToByteArrayTestData() {
|
return new Object[][] { { null, new byte[0] }, { "", new byte[0] },
|
{ "00010f107f80ff", new byte[] { 0, 1, 15, 16, 127, -128, -1 } } };
|
}
|
|
/**
|
* Tests the {@link StaticUtils#hexStringToByteArray(String)} method.
|
*
|
* @param hexString
|
* The test string.
|
* @param bytes
|
* The expected byte array.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "hexStringToByteArrayTestData")
|
public void testHexStringToByteArray(String hexString, byte[] bytes)
|
throws Exception {
|
Assert.assertEquals(StaticUtils.hexStringToByteArray(hexString), bytes);
|
}
|
|
/**
|
* Create test strings for the
|
* {@link StaticUtils#needsBase64Encoding(String)}.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "needsBase64EncodingTestData")
|
public Object[][] createNeedsBase64EncodingTestData() {
|
List<Object[]> data = new LinkedList<Object[]>();
|
|
// Check SAFE-INIT-CHAR.
|
for (char c = '\u0000'; c < '\u0100'; c++) {
|
boolean result = false;
|
|
switch (c) {
|
case '\u0000':
|
case '\r':
|
case '\n':
|
case ' ':
|
case ':':
|
case '<':
|
result = true;
|
break;
|
default:
|
if (c >= '\u0080') {
|
result = true;
|
}
|
break;
|
}
|
|
String s = new String(new char[] { c, 'a', 'b', 'c' });
|
data.add(new Object[] { s, result });
|
}
|
|
// Check SAFE-CHAR.
|
for (char c = '\u0000'; c < '\u0100'; c++) {
|
boolean result = false;
|
|
switch (c) {
|
case '\u0000':
|
case '\r':
|
case '\n':
|
result = true;
|
break;
|
default:
|
if (c >= '\u0080') {
|
result = true;
|
}
|
break;
|
}
|
|
String s = new String(new char[] { 'a', 'b', c, 'c' });
|
data.add(new Object[] { s, result });
|
}
|
|
data.add(new Object[] { null, false });
|
data.add(new Object[] { "", false });
|
data.add(new Object[] { " ", true });
|
data.add(new Object[] { "abc ", true });
|
|
return data.toArray(new Object[2][]);
|
}
|
|
/**
|
* Tests the {@link StaticUtils#needsBase64Encoding(String)} method.
|
*
|
* @param s
|
* The test string.
|
* @param result
|
* The expected result.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "needsBase64EncodingTestData")
|
public void testNeedsBase64EncodingString(String s, boolean result)
|
throws Exception {
|
Assert.assertEquals(StaticUtils.needsBase64Encoding(s), result);
|
}
|
|
/**
|
* Tests the {@link StaticUtils#needsBase64Encoding(ByteSequence)} method.
|
*
|
* @param s
|
* The test string.
|
* @param result
|
* The expected result.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "needsBase64EncodingTestData")
|
public void testNeedsBase64EncodingBytes(String s, boolean result)
|
throws Exception {
|
ByteString bytes = s != null ? ByteString.valueOf(s) : null;
|
Assert.assertEquals(StaticUtils.needsBase64Encoding(bytes), result);
|
}
|
|
/**
|
* Create test strings for the
|
* {@link StaticUtils#isRelativePath(String)}.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "isRelativePathTestData")
|
public Object[][] createIsRelativePathTestData() {
|
String root = File.listRoots()[0].getPath();
|
return new Object[][] { { "", true }, { root, false },
|
{ root + "foo", false }, { "foo", true },
|
{ "foo" + File.separator + "bar", true },
|
{ root + "foo" + File.separator + "bar", false },
|
{ ".", true }, { "..", true },
|
{ root + "foo" + File.separator + ".", false },
|
{ root + "foo" + File.separator + "..", false } };
|
}
|
|
/**
|
* Tests the {@link StaticUtils#isRelativePath(String)} method.
|
*
|
* @param path
|
* The test string.
|
* @param result
|
* Expected result.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "isRelativePathTestData")
|
public void testIsRelativePath(String path, boolean result)
|
throws Exception {
|
Assert.assertEquals(StaticUtils.isRelativePath(path), result);
|
}
|
|
/**
|
* Create test lists for the {@link StaticUtils#listToArray(List)}.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "listToArrayTestData")
|
public Object[][] createListToArrayTestData() {
|
return new Object[][] { { null }, { new String[] {} },
|
{ new String[] { "aaa" } },
|
{ new String[] { "aaa", "bbb", "ccc" } } };
|
}
|
|
/**
|
* Tests the {@link StaticUtils#listToArray(List)} method.
|
*
|
* @param strings
|
* The test string list.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "listToArrayTestData")
|
public void testListToArray(String[] strings) throws Exception {
|
if (strings != null) {
|
List<String> list = new ArrayList<String>(strings.length);
|
for (String string : strings) {
|
list.add(string);
|
}
|
Assert.assertEquals(StaticUtils.listToArray(list), strings);
|
} else {
|
Assert.assertNull(StaticUtils.listToArray(null));
|
}
|
}
|
|
/**
|
* Tests the {@link StaticUtils#moveFile(java.io.File, java.io.File)}
|
* method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = IOException.class)
|
public void testMoveFileNonExistentSrc() throws Exception {
|
File src = File.createTempFile("src", null);
|
File dst = TestCaseUtils.createTemporaryDirectory("dst");
|
File newSrc = new File(dst, src.getName());
|
|
src.delete();
|
|
try {
|
StaticUtils.moveFile(src, dst);
|
} finally {
|
src.delete();
|
dst.delete();
|
newSrc.delete();
|
}
|
}
|
|
/**
|
* Tests the {@link StaticUtils#moveFile(java.io.File, java.io.File)}
|
* method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = IOException.class)
|
public void testMoveFileNonExistentDst() throws Exception {
|
File src = File.createTempFile("src", null);
|
File dst = TestCaseUtils.createTemporaryDirectory("dst");
|
File newSrc = new File(dst, src.getName());
|
|
dst.delete();
|
|
try {
|
StaticUtils.moveFile(src, dst);
|
} finally {
|
src.delete();
|
dst.delete();
|
newSrc.delete();
|
}
|
}
|
|
/**
|
* Tests the {@link StaticUtils#moveFile(java.io.File, java.io.File)}
|
* method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = IOException.class)
|
public void testMoveFileSrcNotFile() throws Exception {
|
File src = TestCaseUtils.createTemporaryDirectory("src");
|
File dst = TestCaseUtils.createTemporaryDirectory("dst");
|
File newSrc = new File(dst, src.getName());
|
|
try {
|
StaticUtils.moveFile(src, dst);
|
} finally {
|
src.delete();
|
dst.delete();
|
newSrc.delete();
|
}
|
}
|
|
/**
|
* Tests the {@link StaticUtils#moveFile(java.io.File, java.io.File)}
|
* method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(expectedExceptions = IOException.class)
|
public void testMoveFileDstNotDirectory() throws Exception {
|
File src = File.createTempFile("src", null);
|
File dst = File.createTempFile("dst", null);
|
File newSrc = new File(dst, src.getName());
|
|
try {
|
StaticUtils.moveFile(src, dst);
|
} finally {
|
src.delete();
|
dst.delete();
|
newSrc.delete();
|
}
|
}
|
|
/**
|
* Create test content for {@link StaticUtils#moveFile(File, File)}.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "moveFileTestData")
|
public Object[][] createMoveFileTestData() {
|
return new Object[][] { { new String[] {} }, { new String[] { "" } },
|
{ new String[] { "", "" } }, { new String[] { " " } },
|
{ new String[] { " ", "", " " } },
|
{ new String[] { "one two three", "four five six", "seven" } } };
|
}
|
|
/**
|
* Tests the {@link StaticUtils#moveFile(java.io.File, java.io.File)}
|
* method.
|
*
|
* @param lines
|
* The test file contents.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "moveFileTestData")
|
public void testMoveFile(String[] lines) throws Exception {
|
File src = File.createTempFile("src", null);
|
File dst = TestCaseUtils.createTemporaryDirectory("dst");
|
File newSrc = new File(dst, src.getName());
|
|
try {
|
// Generate contents.
|
PrintWriter writer = new PrintWriter(new BufferedWriter(
|
new FileWriter(src)));
|
|
for (String line : lines) {
|
writer.println(line);
|
}
|
writer.close();
|
|
// Move the file.
|
StaticUtils.moveFile(src, dst);
|
|
// Post conditions.
|
Assert.assertFalse(src.exists());
|
|
Assert.assertTrue(newSrc.exists());
|
|
BufferedReader reader = new BufferedReader(new FileReader(newSrc));
|
for (String line : lines) {
|
Assert.assertEquals(reader.readLine(), line);
|
}
|
Assert.assertNull(reader.readLine());
|
reader.close();
|
} finally {
|
src.delete();
|
dst.delete();
|
newSrc.delete();
|
}
|
}
|
|
/**
|
* Tests the {@link StaticUtils#renameFile(java.io.File, java.io.File)}
|
* method.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test
|
public void testRenameFileNonExistentTarget() throws Exception {
|
File src = File.createTempFile("src", null);
|
File target = new File(src.getParentFile(), "target");
|
try {
|
if (target.exists()) {
|
target.delete();
|
assert(!target.exists());
|
}
|
StaticUtils.renameFile(src, target);
|
assert(!src.exists());
|
assert(target.exists());
|
} finally {
|
src.delete();
|
target.delete();
|
}
|
}
|
|
/**
|
* Tests the {@link StaticUtils#renameFile(java.io.File, java.io.File)}
|
* method.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test
|
public void testRenameFileExistentTarget() throws Exception {
|
File src = File.createTempFile("src", null);
|
File target = File.createTempFile("target", null);
|
try {
|
StaticUtils.renameFile(src, target);
|
assert(!src.exists());
|
assert(target.exists());
|
} finally {
|
src.delete();
|
target.delete();
|
}
|
}
|
|
/**
|
* Tests the {@link StaticUtils#renameFile(java.io.File, java.io.File)}
|
* method. Renaming locked files is a problem on Windows but not so
|
* much on other platforms.
|
*
|
* @throws Exception If the test failed unexpectedly.
|
*/
|
@Test(groups={"windows"}, expectedExceptions=IOException.class)
|
public void testRenameFileLockedTarget() throws Exception {
|
File src = File.createTempFile("src", null);
|
File target = File.createTempFile("target", null);
|
FileChannel c = new RandomAccessFile(target, "rw").getChannel();
|
FileLock lock = c.lock();
|
try {
|
StaticUtils.renameFile(src, target);
|
} finally {
|
lock.release();
|
src.delete();
|
target.delete();
|
}
|
}
|
|
/**
|
* Tests the {@link StaticUtils#recursiveDelete(File)} method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test
|
public void testRecursiveDeleteNonExistent() throws Exception {
|
File src = File.createTempFile("src", null);
|
src.delete();
|
|
Assert.assertFalse(StaticUtils.recursiveDelete(src));
|
}
|
|
/**
|
* Tests the {@link StaticUtils#recursiveDelete(File)} method.
|
*
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test
|
public void testRecursiveDelete() throws Exception {
|
File dir0 = TestCaseUtils.createTemporaryDirectory("dst");
|
|
List<File> files = new LinkedList<File>();
|
|
File dir1 = new File(dir0, "one");
|
dir1.mkdir();
|
files.add(dir1);
|
|
File dir2 = new File(dir0, "two");
|
dir2.mkdir();
|
files.add(dir2);
|
|
File dir3 = new File(dir0, "three");
|
dir3.mkdir();
|
files.add(dir3);
|
|
File dir4 = new File(dir1, "four");
|
dir4.mkdir();
|
files.add(dir4);
|
|
File f1 = new File(dir1, "f1");
|
f1.createNewFile();
|
files.add(f1);
|
|
File f2 = new File(dir1, "f2");
|
f2.createNewFile();
|
files.add(f2);
|
|
File f3 = new File(dir2, "f3");
|
f3.createNewFile();
|
files.add(f3);
|
|
Assert.assertTrue(StaticUtils.recursiveDelete(dir0));
|
|
for (File f : files) {
|
Assert.assertFalse(f.exists());
|
}
|
}
|
|
/**
|
* Create test strings for the {@link StaticUtils#toLowerCase(String)}
|
* related methods.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "stringCaseConversionTestData")
|
public Object[][] createStringCaseConversionTestData() {
|
return new Object[][] {
|
{ null, null, null },
|
{ "", "", "" },
|
{ " ", " ", " " },
|
{ " a B c ", " a b c ", " A B C " },
|
{
|
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789{}|[]:;'<>?,./!@#$%^&*()_+",
|
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789{}|[]:;'<>?,./!@#$%^&*()_+",
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789{}|[]:;'<>?,./!@#$%^&*()_+" },
|
{ "some non-ascii \u00c0\u00e0\u00c6\u00e6\u00dd\u00fd",
|
"some non-ascii \u00e0\u00e0\u00e6\u00e6\u00fd\u00fd",
|
"SOME NON-ASCII \u00c0\u00c0\u00c6\u00c6\u00dd\u00dd" } };
|
}
|
|
/**
|
* Tests the {@link StaticUtils#toLowerCase(String)} method.
|
*
|
* @param input
|
* The test string.
|
* @param lower
|
* The test string in lower case.
|
* @param upper
|
* The test string in upper case.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "stringCaseConversionTestData")
|
public void testToLowerCaseString(String input, String lower, String upper)
|
throws Exception {
|
Assert.assertEquals(StaticUtils.toLowerCase(input), lower);
|
}
|
|
/**
|
* Tests the
|
* {@link StaticUtils#toLowerCase(ByteSequence, StringBuilder, boolean)}
|
* method.
|
*
|
* @param input
|
* The test string.
|
* @param lower
|
* The test string in lower case.
|
* @param upper
|
* The test string in upper case.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "stringCaseConversionTestData")
|
public void testToLowerCaseBytes(String input, String lower, String upper)
|
throws Exception {
|
ByteString bytes = input != null ? ByteString.valueOf(input) : null;
|
StringBuilder buffer = new StringBuilder();
|
StaticUtils.toLowerCase(bytes, buffer, false);
|
Assert.assertEquals(buffer.toString(), input != null ? lower : "");
|
}
|
|
/**
|
* Tests the {@link StaticUtils#toUpperCase(String)} method.
|
*
|
* @param input
|
* The test string.
|
* @param lower
|
* The test string in lower case.
|
* @param upper
|
* The test string in upper case.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "stringCaseConversionTestData")
|
public void testToUpperCaseString(String input, String lower, String upper)
|
throws Exception {
|
Assert.assertEquals(StaticUtils.toUpperCase(input), upper);
|
}
|
|
/**
|
* Tests the
|
* {@link StaticUtils#toUpperCase(byte[], StringBuilder, boolean)}
|
* method.
|
*
|
* @param input
|
* The test string.
|
* @param lower
|
* The test string in lower case.
|
* @param upper
|
* The test string in upper case.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "stringCaseConversionTestData")
|
public void testToUpperCaseBytes(String input, String lower, String upper)
|
throws Exception {
|
byte[] bytes = input != null ? input.getBytes("UTF-8") : null;
|
StringBuilder buffer = new StringBuilder();
|
StaticUtils.toUpperCase(bytes, buffer, false);
|
Assert.assertEquals(buffer.toString(), input != null ? upper : "");
|
}
|
|
/**
|
* Create test strings for the
|
* {@link StaticUtils#toRFC3641StringValue(StringBuilder, String)}
|
* method.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "toRFC3641StringValueTestData")
|
public Object[][] createToRFC3641StringValueTestData() {
|
return new Object[][] { { "", "\"\"" }, { " ", "\" \"" },
|
{ " a B c ", "\" a B c \"" },
|
{ " \"hello world\" ", "\" \"\"hello world\"\" \"" },
|
{ "\"\"\"", "\"\"\"\"\"\"\"\"" }, };
|
}
|
|
/**
|
* Tests the
|
* {@link StaticUtils#toRFC3641StringValue(StringBuilder, String)}
|
* method.
|
*
|
* @param input
|
* The test string.
|
* @param expected
|
* The expected result.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "toRFC3641StringValueTestData")
|
public void testToRFC3641StringValue(String input, String expected)
|
throws Exception {
|
StringBuilder builder = new StringBuilder();
|
StaticUtils.toRFC3641StringValue(builder, input);
|
Assert.assertEquals(builder.toString(), expected);
|
}
|
|
/**
|
* Create test lists for the
|
* {@link StaticUtils#listsAreEqual(List, List)} method.
|
*
|
* @return Returns an array of test data.
|
*/
|
@DataProvider(name = "listsAreEqualTestData")
|
public Object[][] createListsAreEqualTestData() {
|
return new Object[][] {
|
// Check null behaviour.
|
{ null, null, true },
|
{ null, Collections.emptyList(), false },
|
{ Collections.emptyList(), null, false },
|
|
// Check empty-list behaviour.
|
{ Collections.emptyList(), Collections.emptyList(), true },
|
{ Collections.singletonList(0), Collections.emptyList(), false },
|
{ Collections.emptyList(), Collections.singletonList(0), false },
|
|
// Check single-element behaviour.
|
{ Collections.singletonList(0), Collections.singletonList(0), true },
|
{ Collections.singletonList(0), Collections.singletonList(1), false },
|
|
// Check multi-element random access behaviour.
|
{ Arrays.asList(0, 1), Arrays.asList(0, 1), true },
|
{ Arrays.asList(0, 1), Arrays.asList(1, 0), false },
|
|
// ...With duplicates.
|
{ Arrays.asList(0, 1), Arrays.asList(0, 1, 1), false },
|
|
// Check multi-element sequential behaviour.
|
{ new LinkedList<Integer>(Arrays.asList(0, 1)),
|
new LinkedList<Integer>(Arrays.asList(0, 1)), true },
|
{ new LinkedList<Integer>(Arrays.asList(0, 1)),
|
new LinkedList<Integer>(Arrays.asList(1, 0)), false },
|
|
// ...With duplicates.
|
{ new LinkedList<Integer>(Arrays.asList(0, 1)),
|
new LinkedList<Integer>(Arrays.asList(0, 1, 1)), false } };
|
}
|
|
/**
|
* Tests the {@link StaticUtils#listsAreEqual(List, List)} method.
|
*
|
* @param list1
|
* The first list.
|
* @param list2
|
* The second list.
|
* @param result
|
* The expected equality result.
|
* @throws Exception
|
* If the test failed unexpectedly.
|
*/
|
@Test(dataProvider = "listsAreEqualTestData")
|
public void testListsAreEqual(List<?> list1, List<?> list2, boolean result)
|
throws Exception {
|
Assert.assertEquals(StaticUtils.listsAreEqual(list1, list2), result);
|
}
|
}
|
