Serge NOEL
557 lines
24 KiB
Java
557 lines
24 KiB
Java
package jmri.util;
|
|
|
|
import java.util.Arrays;
|
|
|
|
import org.junit.jupiter.api.*;
|
|
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
import static org.junit.jupiter.api.Assertions.assertNull;
|
|
|
|
/**
|
|
* Tests for the jmri.util.StringUtil class.
|
|
*
|
|
* @author Bob Jacobsen Copyright 2003
|
|
*/
|
|
public class StringUtilTest {
|
|
|
|
@Test
|
|
public void testFindMatch1() {
|
|
String[] s = new String[]{"A", "B", "C"};
|
|
int[] num = new int[]{20, 30, 40};
|
|
int[] masks = new int[]{0xFF, 0xFF, 0xFF};
|
|
|
|
assertEquals( 1, StringUtil.getNamesFromStateMasked(20, num, masks, s).length, "A length");
|
|
assertEquals( "A", StringUtil.getNamesFromStateMasked(20, num, masks, s)[0], "A value ");
|
|
|
|
assertEquals( 1, StringUtil.getNamesFromStateMasked(30, num, masks, s).length, "B length");
|
|
assertEquals( "B", StringUtil.getNamesFromStateMasked(30, num, masks, s)[0], "B value ");
|
|
|
|
assertEquals( 1, StringUtil.getNamesFromStateMasked(40, num, masks, s).length, "C length");
|
|
assertEquals( "C", StringUtil.getNamesFromStateMasked(40, num, masks, s)[0], "C value ");
|
|
|
|
assertEquals( 0, StringUtil.getNamesFromStateMasked(80, num, masks, s).length, "D null");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testFindMatch2() {
|
|
String[] s = new String[]{"A", "B", "C"};
|
|
int[] num = new int[]{0x20, 0x30, 0x40};
|
|
int[] masks = new int[]{0xF0, 0xF0, 0xF0};
|
|
|
|
assertEquals( 1, StringUtil.getNamesFromStateMasked(0x21, num, masks, s).length, "A length");
|
|
assertEquals( "A", StringUtil.getNamesFromStateMasked(0x21, num, masks, s)[0], "A value ");
|
|
|
|
assertEquals( 1, StringUtil.getNamesFromStateMasked(0x34, num, masks, s).length, "B length");
|
|
assertEquals( "B", StringUtil.getNamesFromStateMasked(0x34, num, masks, s)[0], "B value ");
|
|
|
|
assertEquals( 1, StringUtil.getNamesFromStateMasked(0x4F, num, masks, s).length, "C length");
|
|
assertEquals( "C", StringUtil.getNamesFromStateMasked(0x4F, num, masks, s)[0], "C value ");
|
|
|
|
assertEquals( 0, StringUtil.getNamesFromStateMasked(0x80, num, masks, s).length, "D null");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testFindMatch3() {
|
|
String[] s = new String[]{"A", "B", "C"};
|
|
int[] num = new int[]{0x20, 0x30, 0x40};
|
|
int[] masks = new int[]{0x20, 0x30, 0x40};
|
|
|
|
assertEquals( 1, StringUtil.getNamesFromStateMasked(0x21, num, masks, s).length, "A length");
|
|
assertEquals( "A", StringUtil.getNamesFromStateMasked(0x21, num, masks, s)[0], "A value ");
|
|
|
|
assertEquals( 2, StringUtil.getNamesFromStateMasked(0x34, num, masks, s).length, "B length");
|
|
assertEquals( "A", StringUtil.getNamesFromStateMasked(0x34, num, masks, s)[0], "B value 1");
|
|
assertEquals( "B", StringUtil.getNamesFromStateMasked(0x34, num, masks, s)[1], "B value 2");
|
|
|
|
assertEquals( 1, StringUtil.getNamesFromStateMasked(0x4F, num, masks, s).length, "C length");
|
|
assertEquals( "C", StringUtil.getNamesFromStateMasked(0x4F, num, masks, s)[0], "C value ");
|
|
|
|
assertEquals( 0, StringUtil.getNamesFromStateMasked(0x80, num, masks, s).length, "D null");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testGetNamesFromState() {
|
|
|
|
String[] s = new String[]{"A", "B", "C", "D"};
|
|
int[] num = new int[]{0, 1, 2, 4};
|
|
|
|
assertEquals( 1, StringUtil.getNamesFromState(0, num, s).length);
|
|
assertEquals( "A", StringUtil.getNamesFromState(0, num, s)[0]);
|
|
|
|
assertEquals( 1, StringUtil.getNamesFromState(1, num, s).length);
|
|
assertEquals( "B", StringUtil.getNamesFromState(1, num, s)[0]);
|
|
|
|
assertEquals( 1, StringUtil.getNamesFromState(2, num, s).length);
|
|
assertEquals( "C", StringUtil.getNamesFromState(2, num, s)[0]);
|
|
|
|
assertEquals( 2, StringUtil.getNamesFromState(3, num, s).length);
|
|
assertEquals( "B", StringUtil.getNamesFromState(3, num, s)[0]);
|
|
assertEquals( "C", StringUtil.getNamesFromState(3, num, s)[1]);
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testFindState() {
|
|
String[] s = new String[]{"A", "B", "C"};
|
|
int[] n = new int[]{20, 30, 40};
|
|
|
|
assertEquals( 20, StringUtil.getStateFromName("A", n, s), "A");
|
|
assertEquals( 30, StringUtil.getStateFromName("B", n, s), "B");
|
|
assertEquals( 40, StringUtil.getStateFromName("C", n, s), "C");
|
|
}
|
|
|
|
@Test
|
|
public void testFindName() {
|
|
String[] s = new String[]{"A", "B", "C"};
|
|
int[] n = new int[]{20, 30, 40};
|
|
|
|
assertEquals( "A", StringUtil.getNameFromState(20, n, s), "A");
|
|
assertEquals( "B", StringUtil.getNameFromState(30, n, s), "B");
|
|
assertEquals( "C", StringUtil.getNameFromState(40, n, s), "C");
|
|
}
|
|
|
|
@Test
|
|
public void testHexFromInt() {
|
|
assertEquals("00", StringUtil.twoHexFromInt(0));
|
|
assertEquals("01", StringUtil.twoHexFromInt(1));
|
|
assertEquals("02", StringUtil.twoHexFromInt(2));
|
|
assertEquals("03", StringUtil.twoHexFromInt(3));
|
|
assertEquals("09", StringUtil.twoHexFromInt(9));
|
|
assertEquals("0A", StringUtil.twoHexFromInt(10));
|
|
assertEquals("0B", StringUtil.twoHexFromInt(11));
|
|
assertEquals("0E", StringUtil.twoHexFromInt(14));
|
|
assertEquals("0F", StringUtil.twoHexFromInt(15));
|
|
assertEquals("10", StringUtil.twoHexFromInt(16));
|
|
assertEquals("11", StringUtil.twoHexFromInt(17));
|
|
assertEquals("80", StringUtil.twoHexFromInt(0x80));
|
|
assertEquals("FF", StringUtil.twoHexFromInt(0xFF));
|
|
}
|
|
|
|
@Test
|
|
public void testHexFromIntFromByte() {
|
|
assertEquals("00", StringUtil.twoHexFromInt((byte) 0));
|
|
assertEquals("01", StringUtil.twoHexFromInt((byte) 1));
|
|
assertEquals("02", StringUtil.twoHexFromInt((byte) 2));
|
|
assertEquals("11", StringUtil.twoHexFromInt((byte) 17));
|
|
assertEquals("80", StringUtil.twoHexFromInt((byte) 0x80));
|
|
assertEquals("FF", StringUtil.twoHexFromInt((byte) 0xFF));
|
|
}
|
|
|
|
@Test
|
|
public void testAppHexFromInt() {
|
|
assertEquals("00", StringUtil.appendTwoHexFromInt(0, ""));
|
|
assertEquals("01", StringUtil.appendTwoHexFromInt(1, ""));
|
|
assertEquals("02", StringUtil.appendTwoHexFromInt(2, ""));
|
|
assertEquals("03", StringUtil.appendTwoHexFromInt(3, ""));
|
|
assertEquals("09", StringUtil.appendTwoHexFromInt(9, ""));
|
|
assertEquals("0A", StringUtil.appendTwoHexFromInt(10, ""));
|
|
assertEquals("0B", StringUtil.appendTwoHexFromInt(11, ""));
|
|
assertEquals("0E", StringUtil.appendTwoHexFromInt(14, ""));
|
|
assertEquals("0F", StringUtil.appendTwoHexFromInt(15, ""));
|
|
assertEquals("10", StringUtil.appendTwoHexFromInt(16, ""));
|
|
assertEquals("11", StringUtil.appendTwoHexFromInt(17, ""));
|
|
assertEquals("80", StringUtil.appendTwoHexFromInt(0x80, ""));
|
|
assertEquals("FF", StringUtil.appendTwoHexFromInt(0xFF, ""));
|
|
}
|
|
|
|
@Test
|
|
public void testAppHexFromIntFromByte() {
|
|
assertEquals("00", StringUtil.appendTwoHexFromInt((byte) 0, ""));
|
|
assertEquals("01", StringUtil.appendTwoHexFromInt((byte) 1, ""));
|
|
assertEquals("02", StringUtil.appendTwoHexFromInt((byte) 2, ""));
|
|
assertEquals("11", StringUtil.appendTwoHexFromInt((byte) 17, ""));
|
|
assertEquals("80", StringUtil.appendTwoHexFromInt((byte) 0x80, ""));
|
|
assertEquals("FF", StringUtil.appendTwoHexFromInt((byte) 0xFF, ""));
|
|
}
|
|
|
|
@Test
|
|
public void testParseStringNull() {
|
|
byte[] b = StringUtil.bytesFromHexString("");
|
|
assertEquals( 0, b.length, "array length");
|
|
}
|
|
|
|
@Test
|
|
public void testParseSingleDigit() {
|
|
byte[] b = StringUtil.bytesFromHexString("A");
|
|
assertEquals( 1, b.length, "array length");
|
|
assertEquals( 0x0A, b[0], "0th byte");
|
|
}
|
|
|
|
@Test
|
|
public void testParseDoubleDigit() {
|
|
byte[] b = StringUtil.bytesFromHexString("AB");
|
|
assertEquals( 1, b.length, "array length");
|
|
assertEquals( 0xAB, b[0] & 0xFF, "0th byte");
|
|
}
|
|
|
|
@Test
|
|
public void testParseSeveral() {
|
|
byte[] b = StringUtil.bytesFromHexString("12 34 AB 3 19 6 B B1");
|
|
assertEquals( 8, b.length, "array length");
|
|
assertEquals( 0x12, b[0] & 0xFF, "0th byte");
|
|
assertEquals( 0x34, b[1] & 0xFF, "1st byte");
|
|
assertEquals( 0xAB, b[2] & 0xFF, "2nd byte");
|
|
assertEquals( 0x03, b[3] & 0xFF, "3rd byte");
|
|
assertEquals( 0x19, b[4] & 0xFF, "4th byte");
|
|
assertEquals( 0x06, b[5] & 0xFF, "5th byte");
|
|
assertEquals( 0x0B, b[6] & 0xFF, "6th byte");
|
|
assertEquals( 0xB1, b[7] & 0xFF, "7th byte");
|
|
}
|
|
|
|
@Test
|
|
public void testparenQuote() {
|
|
String sample;
|
|
|
|
assertNull( StringUtil.parenQuote(null), "null String");
|
|
|
|
sample = "";
|
|
assertEquals( sample, StringUtil.parenQuote(sample), sample);
|
|
|
|
sample = "abc";
|
|
assertEquals( sample, StringUtil.parenQuote(sample), sample);
|
|
|
|
sample = "123";
|
|
assertEquals( sample, StringUtil.parenQuote(sample), sample);
|
|
|
|
sample = "";
|
|
assertEquals( sample, StringUtil.parenQuote(sample), sample);
|
|
|
|
sample = "a\\b";
|
|
assertEquals( "a\\\\b", StringUtil.parenQuote(sample), sample);
|
|
|
|
sample = "a(v)c";
|
|
assertEquals( sample, StringUtil.parenQuote(sample), sample);
|
|
|
|
sample = "a(v(b)(n)K)";
|
|
assertEquals( sample, StringUtil.parenQuote(sample), sample);
|
|
|
|
sample = "()((()))";
|
|
assertEquals( sample, StringUtil.parenQuote(sample), sample);
|
|
|
|
sample = "a)b";
|
|
assertEquals( "a\\)b", StringUtil.parenQuote(sample), sample);
|
|
}
|
|
|
|
@Test
|
|
public void testparenUnQuote() {
|
|
String sample;
|
|
|
|
assertNull( StringUtil.parenUnQuote(null), "Null String");
|
|
|
|
sample = "";
|
|
assertEquals( sample, StringUtil.parenUnQuote(sample), sample);
|
|
|
|
sample = "abc";
|
|
assertEquals( sample, StringUtil.parenUnQuote(sample), sample);
|
|
|
|
sample = "123";
|
|
assertEquals( sample, StringUtil.parenUnQuote(sample), sample);
|
|
|
|
sample = "";
|
|
assertEquals( sample, StringUtil.parenUnQuote(sample), sample);
|
|
|
|
sample = "a\\\\b";
|
|
assertEquals( "a\\b", StringUtil.parenUnQuote(sample), sample);
|
|
|
|
sample = "a(v)c";
|
|
assertEquals( sample, StringUtil.parenUnQuote(sample), sample);
|
|
|
|
sample = "a(v(b)(n)K)";
|
|
assertEquals( sample, StringUtil.parenUnQuote(sample), sample);
|
|
|
|
sample = "()((()))";
|
|
assertEquals( sample, StringUtil.parenUnQuote(sample), sample);
|
|
|
|
sample = "a\\)b";
|
|
assertEquals( "a)b", StringUtil.parenUnQuote(sample), sample);
|
|
}
|
|
|
|
@Test
|
|
public void testSplitParens() {
|
|
String sample;
|
|
java.util.List<String> list;
|
|
|
|
sample = "(abc)";
|
|
list = StringUtil.splitParens(sample);
|
|
assertEquals( 1, list.size(), sample);
|
|
assertEquals( "(abc)", list.get(0), sample + " 1");
|
|
|
|
sample = "(abc)(def)";
|
|
list = StringUtil.splitParens(sample);
|
|
assertEquals( 2, list.size(), sample);
|
|
assertEquals( "(abc)", list.get(0), sample + " 1");
|
|
assertEquals( "(def)", list.get(1), sample + " 1");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testArrayToString() {
|
|
Object[] a = new Object[]{"A", "B", "C"};
|
|
assertEquals( "[A],[B],[C]", StringUtil.arrayToString(a), "Object");
|
|
|
|
String[] b = new String[]{"X", "Y", "Z"};
|
|
assertEquals( "[X],[Y],[Z]", StringUtil.arrayToString(b), "Object");
|
|
|
|
byte[] c = new byte[]{1, 2, 3};
|
|
assertEquals( "[1],[2],[3]", StringUtil.arrayToString(c), "Object");
|
|
|
|
int[] d = new int[]{1, 2, 3};
|
|
assertEquals( "[1],[2],[3]", StringUtil.arrayToString(d), "Object");
|
|
}
|
|
|
|
@Test
|
|
public void testGetFirstIntFromString() {
|
|
assertEquals( 123, StringUtil.getFirstIntFromString("aABC123DEFb"), "F aABC123DEFb");
|
|
assertEquals( -1, StringUtil.getFirstIntFromString(""), "F no val");
|
|
assertEquals( 0, StringUtil.getFirstIntFromString("0"), "F 0");
|
|
assertEquals( 2, StringUtil.getFirstIntFromString("+2"), "F +2");
|
|
assertEquals( 5, StringUtil.getFirstIntFromString("-5"), "F -5");
|
|
assertEquals( 123, StringUtil.getFirstIntFromString("ABC123DEF"), "F ABC123DEF");
|
|
assertEquals( 123, StringUtil.getFirstIntFromString("ABC123"), "F ABC123");
|
|
assertEquals( 123, StringUtil.getFirstIntFromString("123"), "F 123");
|
|
assertEquals( 123, StringUtil.getFirstIntFromString("123ABC"), "F 123ABC");
|
|
assertEquals( 12, StringUtil.getFirstIntFromString("AB12 34ABC"), "F AB12 34ABC");
|
|
assertEquals( 123, StringUtil.getFirstIntFromString("123 ABC"), "F 123 ABC ");
|
|
assertEquals( 123, StringUtil.getFirstIntFromString("123ABC456"), "F 123ABC456");
|
|
assertEquals( 123, StringUtil.getFirstIntFromString("123A654BC456"), "F 123A654BC456");
|
|
assertEquals( 123, StringUtil.getFirstIntFromString("XD+123ABC-456"), "F XD+123ABC-456");
|
|
assertEquals( 456, StringUtil.getFirstIntFromString("A c456fg123ABC789jh"), "F A c456fg123ABC789jh");
|
|
}
|
|
|
|
@Test
|
|
public void testGetLastIntFromString() {
|
|
assertEquals( 123, StringUtil.getLastIntFromString("aABC123DEFb"), "aABC123DEFb");
|
|
assertEquals( -1, StringUtil.getLastIntFromString(""), "no val");
|
|
assertEquals( 0, StringUtil.getLastIntFromString("0"), "0");
|
|
assertEquals( 2, StringUtil.getLastIntFromString("+2"), "+2");
|
|
assertEquals( 5, StringUtil.getLastIntFromString("-5"), "-5");
|
|
assertEquals( 123, StringUtil.getLastIntFromString("ABC123DEF"), "ABC123DEF");
|
|
assertEquals( 123, StringUtil.getLastIntFromString("ABC123"), "ABC123");
|
|
assertEquals( 123, StringUtil.getLastIntFromString("123"), "123");
|
|
assertEquals( 123, StringUtil.getLastIntFromString("123ABC"), "123ABC");
|
|
assertEquals( 34, StringUtil.getLastIntFromString("AB12 34ABC"), "AB12 34ABC");
|
|
assertEquals( 123, StringUtil.getLastIntFromString("123 ABC "), "123 ABC ");
|
|
assertEquals( 456, StringUtil.getLastIntFromString("123ABC456"), "123ABC456");
|
|
assertEquals( 456, StringUtil.getLastIntFromString("123A654BC456"), "123A654BC456");
|
|
assertEquals( 456, StringUtil.getLastIntFromString("XD+123ABC-456"), "XD+123ABC-456");
|
|
assertEquals( 789, StringUtil.getLastIntFromString("Ac456fg123ABC789jh"), "Ac456fg123ABC789jh");
|
|
}
|
|
|
|
@Test
|
|
public void testReplaceLast() {
|
|
assertEquals( "", StringUtil.replaceLast("", "", ""), "no vals");
|
|
assertEquals( "D4F5gaz", StringUtil.replaceLast("D4F5gaz", "", ""), "D4F5gaz");
|
|
assertEquals( "D4S1gaz", StringUtil.replaceLast("D4F5gaz", "F5", "S1"), "D4F5gaz F5 S1");
|
|
assertEquals( "D4F5g1234", StringUtil.replaceLast("D4F5g123", "123", "1234"), "D4F5g1234");
|
|
assertEquals( "77YYYzz", StringUtil.replaceLast("xxYYYzz", "xx", "77"), "77YYYzz");
|
|
assertEquals( "xxAA77YYYzz", StringUtil.replaceLast("xxAAxxYYYzz", "xx", "77"), "xxAA77YYYzz");
|
|
assertEquals( "122", StringUtil.replaceLast("121", "1", "2"), "122");
|
|
assertEquals( "121", StringUtil.replaceLast("121", "Z", "2"), "122 Z");
|
|
}
|
|
|
|
/**
|
|
* Test of concatTextHtmlAware method, of class StringUtil.
|
|
*/
|
|
@Test
|
|
public void testConcatTextHtmlAware() {
|
|
String baseText = "Some text";
|
|
String extraText = " and extra stuff";
|
|
|
|
String baseTextHtml = "<html>" + baseText + "</html>";
|
|
String extraTextHtml = "<html>" + extraText + "</html>";
|
|
|
|
String baseTextHtmlUpper = "<HTML>" + baseText + "</HTML>";
|
|
String extraTextHtmlUpper = "<HTML>" + extraText + "</HTML>";
|
|
|
|
String expResultNoHtml = baseText + extraText;
|
|
String expResultHtml = "<html>" + expResultNoHtml + "</html>";
|
|
|
|
// test null cases
|
|
assertNull( StringUtil.concatTextHtmlAware(null, null));
|
|
assertEquals(baseText, StringUtil.concatTextHtmlAware(baseText, null));
|
|
assertEquals(extraText, StringUtil.concatTextHtmlAware(null, extraText));
|
|
assertEquals(baseTextHtml, StringUtil.concatTextHtmlAware(baseTextHtml, null));
|
|
assertEquals(extraTextHtml, StringUtil.concatTextHtmlAware(null, extraTextHtml));
|
|
|
|
// test with no HTML
|
|
String result = StringUtil.concatTextHtmlAware(baseText, extraText);
|
|
assertEquals(expResultNoHtml, result);
|
|
|
|
// test with baseText HTML
|
|
result = StringUtil.concatTextHtmlAware(baseTextHtml, extraText);
|
|
assertEquals(expResultHtml, result);
|
|
|
|
// test with extraText HTML
|
|
result = StringUtil.concatTextHtmlAware(baseText, extraTextHtml);
|
|
assertEquals(expResultHtml, result);
|
|
|
|
// test with both HTML
|
|
result = StringUtil.concatTextHtmlAware(baseTextHtml, extraTextHtml);
|
|
assertEquals(expResultHtml, result);
|
|
|
|
// test with baseText uppercase HTML
|
|
result = StringUtil.concatTextHtmlAware(baseTextHtmlUpper, extraTextHtml);
|
|
assertEquals(expResultHtml, result);
|
|
|
|
// test with extraText uppercase HTML
|
|
result = StringUtil.concatTextHtmlAware(baseTextHtml, extraTextHtmlUpper);
|
|
assertEquals(expResultHtml, result);
|
|
|
|
// test with both uppercase HTML
|
|
result = StringUtil.concatTextHtmlAware(baseTextHtmlUpper, extraTextHtmlUpper);
|
|
assertEquals(expResultHtml, result);
|
|
}
|
|
|
|
@Test
|
|
public void testFullTextToHexArray() {
|
|
|
|
byte[] b = StringUtil.fullTextToHexArray("PAN",7);
|
|
assertEquals( 7, b.length, "array length");
|
|
assertEquals( 0x50, b[0] & 0xFF, "0th byte");
|
|
assertEquals( 0x41, b[1] & 0xFF, "1st byte");
|
|
assertEquals( 0x4E, b[2] & 0xFF, "2nd byte");
|
|
assertEquals( 0x20, b[3] & 0xFF, "3rd byte");
|
|
assertEquals( 0x20, b[4] & 0xFF, "4th byte");
|
|
assertEquals( 0x20, b[5] & 0xFF, "5th byte");
|
|
assertEquals( 0x20, b[6] & 0xFF, "6th byte");
|
|
|
|
b = StringUtil.fullTextToHexArray("CATjhgkjhg jkhg kjhg kjhg jhg ",2);
|
|
assertEquals( 2, b.length, "array length");
|
|
assertEquals( 0x43, b[0] & 0xFF, "0th byte");
|
|
assertEquals( 0x41, b[1] & 0xFF, "1st byte");
|
|
|
|
b = StringUtil.fullTextToHexArray("My FroG",8);
|
|
assertEquals( 8, b.length, "array length");
|
|
assertEquals( 0x4d, b[0] & 0xFF, "0th byte");
|
|
assertEquals( 0x79, b[1] & 0xFF, "1st byte");
|
|
assertEquals( 0x20, b[2] & 0xFF, "2nd byte");
|
|
assertEquals( 0x46, b[3] & 0xFF, "3rd byte");
|
|
assertEquals( 0x72, b[4] & 0xFF, "4th byte");
|
|
assertEquals( 0x6f, b[5] & 0xFF, "5th byte");
|
|
assertEquals( 0x47, b[6] & 0xFF, "6th byte");
|
|
assertEquals( 0x20, b[7] & 0xFF, "7th byte");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testintBytesWithTotalFromNonSpacedHexString(){
|
|
|
|
int[] b = StringUtil.intBytesWithTotalFromNonSpacedHexString("01020AB121",true);
|
|
assertEquals( 6, b.length, "array length");
|
|
assertEquals( "[5, 1, 2, 10, 177, 33]",Arrays.toString(b), "01020AB121 true");
|
|
|
|
b = StringUtil.intBytesWithTotalFromNonSpacedHexString("01020ab121",true);
|
|
assertEquals( "[5, 1, 2, 10, 177, 33]",Arrays.toString(b), "01020ab121 true");
|
|
|
|
b = StringUtil.intBytesWithTotalFromNonSpacedHexString("01020ab121",false);
|
|
assertEquals( "[1, 2, 10, 177, 33]",Arrays.toString(b), "01020ab121 false");
|
|
|
|
b = StringUtil.intBytesWithTotalFromNonSpacedHexString("010",true);
|
|
assertEquals( "[0]",Arrays.toString(b), "010 true");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testGetByte(){
|
|
|
|
assertEquals( 3, StringUtil.getByte(2,"010203"), "010203 2");
|
|
assertEquals( 0, StringUtil.getByte(-1,"010203"), "010203 -1");
|
|
assertEquals( 205, StringUtil.getByte(1,"AbCdEf"), "AbCdEf 1");
|
|
}
|
|
|
|
@Test
|
|
public void testGetHexDigit(){
|
|
|
|
assertEquals( 0, StringUtil.getHexDigit(0,"010203"), "010203 0");
|
|
assertEquals( 1, StringUtil.getHexDigit(1,"010203"), "010203 1");
|
|
assertEquals( 0, StringUtil.getHexDigit(2,"010203"), "010203 2");
|
|
assertEquals( 2, StringUtil.getHexDigit(3,"010203"), "010203 3");
|
|
assertEquals( 0, StringUtil.getHexDigit(4,"010203"), "010203 4");
|
|
assertEquals( 3, StringUtil.getHexDigit(5,"010203"), "010203 5");
|
|
assertEquals( 15, StringUtil.getHexDigit(3,"010F03"), "010F03 3");
|
|
|
|
}
|
|
|
|
@Test
|
|
public void testHexStringFromBytes(){
|
|
assertEquals( "", StringUtil.hexStringFromBytes(new byte[] {}), "Zero Length Array");
|
|
assertEquals( "00 01 02 03 ", StringUtil.hexStringFromBytes(new byte[]{0,1,2,3}), "00010203");
|
|
assertEquals( "00 ", StringUtil.hexStringFromBytes(new byte[]{0}), "0");
|
|
assertEquals( "FF ", StringUtil.hexStringFromBytes(new byte[]{-1}), "-1");
|
|
assertEquals( "AB CD ", StringUtil.hexStringFromBytes(new byte[]{(byte) 0xab,(byte) 0xcd}), "-1");
|
|
assertEquals( "2D 7B 81 D9 ", StringUtil.hexStringFromBytes(new byte[] {45,123,(byte)129,(byte)217}), "45,123,129,217");
|
|
assertEquals( "FF 00 01 ", StringUtil.hexStringFromBytes(new byte[] {(byte)255,(byte)256,(byte)257}), "255,256,257");
|
|
}
|
|
|
|
@Test
|
|
public void testHexStringFromInts(){
|
|
assertEquals( "", StringUtil.hexStringFromInts(new int[] {}), "Zero Length Array");
|
|
assertEquals( "FF ", StringUtil.hexStringFromInts(new int[] {-1}), "-1");
|
|
assertEquals( "00 ", StringUtil.hexStringFromInts(new int[] {0}), "0");
|
|
assertEquals( "00 01 ", StringUtil.hexStringFromInts(new int[] {0,1}), "0,1");
|
|
assertEquals( "2D 7B 81 D9 ", StringUtil.hexStringFromInts(new int[] {45,123,129,217}), "45,123,129,217");
|
|
assertEquals( "FF 00 01 ", StringUtil.hexStringFromInts(new int[] {255,256,257}), "255,256,257");
|
|
}
|
|
|
|
@Test
|
|
public void testIncrementLastNumberInString(){
|
|
assertEquals( null, StringUtil.incrementLastNumberInString("",7), "zero length str");
|
|
assertEquals( null, StringUtil.incrementLastNumberInString("NoNumberInString",1), "no number in str");
|
|
assertEquals( "123", StringUtil.incrementLastNumberInString("123",0 ), "123 0");
|
|
assertEquals( "ABC125DEF", StringUtil.incrementLastNumberInString("ABC123DEF",2), "ABC123DEF 2");
|
|
assertEquals( "ABC100DEF", StringUtil.incrementLastNumberInString("ABC99DEF",1), "ABC99DEF 1");
|
|
assertEquals( "123ABC457", StringUtil.incrementLastNumberInString("123ABC456",1), "123ABC456 1");
|
|
assertEquals( "123ABC0002", StringUtil.incrementLastNumberInString("123ABC0001",1), "123ABC0001 1");
|
|
}
|
|
|
|
@Test
|
|
public void testto8Bits(){
|
|
assertEquals("00000000",StringUtil.to8Bits(0b00000000, true));
|
|
assertEquals("10000000",StringUtil.to8Bits(0b10000000, true));
|
|
assertEquals("01000000",StringUtil.to8Bits(0b01000000, true));
|
|
assertEquals("00100000",StringUtil.to8Bits(0b00100000, true));
|
|
assertEquals("00010000",StringUtil.to8Bits(0b00010000, true));
|
|
assertEquals("00001000",StringUtil.to8Bits(0b00001000, true));
|
|
assertEquals("00000100",StringUtil.to8Bits(0b00000100, true));
|
|
assertEquals("00000010",StringUtil.to8Bits(0b00000010, true));
|
|
assertEquals("00000001",StringUtil.to8Bits(0b00000001, true));
|
|
assertEquals("11111111",StringUtil.to8Bits(0b11111111, true));
|
|
|
|
assertEquals("00000000",StringUtil.to8Bits(0b00000000, false));
|
|
assertEquals("00000001",StringUtil.to8Bits(0b10000000, false));
|
|
assertEquals("00000010",StringUtil.to8Bits(0b01000000, false));
|
|
assertEquals("00000100",StringUtil.to8Bits(0b00100000, false));
|
|
assertEquals("00001000",StringUtil.to8Bits(0b00010000, false));
|
|
assertEquals("00010000",StringUtil.to8Bits(0b00001000, false));
|
|
assertEquals("00100000",StringUtil.to8Bits(0b00000100, false));
|
|
assertEquals("01000000",StringUtil.to8Bits(0b00000010, false));
|
|
assertEquals("10000000",StringUtil.to8Bits(0b00000001, false));
|
|
assertEquals("11111111",StringUtil.to8Bits(0b11111111, false));
|
|
}
|
|
|
|
@Test
|
|
public void testStripHtmlTags() {
|
|
assertEquals("My String",StringUtil.stripHtmlTags("<html>My String</html>"));
|
|
assertEquals("Line1"+System.lineSeparator()+"Line2",StringUtil.stripHtmlTags("<html>Line1<br>Line2</html>"));
|
|
assertEquals("NoTags",StringUtil.stripHtmlTags("NoTags"));
|
|
assertEquals("abc < def",StringUtil.stripHtmlTags("abc < def"));
|
|
assertEquals("ghi > jkl",StringUtil.stripHtmlTags("ghi > jkl"));
|
|
assertEquals("Line3"+System.lineSeparator()+"Line4",StringUtil.stripHtmlTags("<html>Line3<br/>Line4</html>"));
|
|
assertEquals("Line5"+System.lineSeparator()+"Line6",StringUtil.stripHtmlTags("<html>Line5<br />Line6</html>"));
|
|
}
|
|
|
|
@BeforeEach
|
|
public void setUp() {
|
|
JUnitUtil.setUp();
|
|
}
|
|
|
|
@AfterEach
|
|
public void tearDown() {
|
|
JUnitUtil.tearDown();
|
|
}
|
|
|
|
}
|