appc-common/src/test/java/org/onap/appc/util/StringHelperTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP : APPC
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Copyright (C) 2018 Nokia Solutions and Networks
   8  * =============================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * ============LICENSE_END=========================================================
  22  */
  23
  24
  25 package org.onap.appc.util;
  26
  27 import static org.junit.Assert.assertEquals;
  28 import static org.junit.Assert.assertFalse;
  29 import static org.junit.Assert.assertNotNull;
  30 import static org.junit.Assert.assertNull;
  31 import static org.junit.Assert.assertTrue;
  32
  33 import com.google.common.collect.Lists;
  34 import com.google.common.collect.Maps;
  35 import java.util.Arrays;
  36 import java.util.HashMap;
  37 import java.util.List;
  38 import java.util.Map;
  39 import java.util.Properties;
  40
  41 import org.apache.commons.lang3.StringUtils;
  42 import org.junit.Test;
  43 import org.onap.appc.util.StringHelper;
  44
  45
  46 public class StringHelperTest {
  47
  48     //TODO write more tests for convertToRegex method
  49
  50     @Test
  51     public void convertToRegex_should_return_regex_matching_all_string_when_given_null_or_empty_string(){
  52         assertEquals(".*", StringHelper.convertToRegex(null));
  53         assertEquals(".*", StringHelper.convertToRegex(""));
  54         assertEquals(".*", StringHelper.convertToRegex("  "));
  55     }
  56
  57     @Test
  58     public void getShortenedString_should_return_null_when_given_null(){
  59         assertNull(StringHelper.getShortenedString(null, 2));
  60     }
  61
  62     @Test
  63     public void getShortenedString_should_return_given_string_when_length_is_lower_than_4(){
  64         assertEquals("str", StringHelper.getShortenedString("str", 3));
  65         assertEquals("str", StringHelper.getShortenedString("str", 2));
  66         assertEquals("test", StringHelper.getShortenedString("test", 3));
  67     }
  68
  69     @Test
  70     public void getShortenedString_should_shorten_string_and_append_ellipsis(){
  71
  72         assertEquals("s...", StringHelper.getShortenedString("sample", 4));
  73         assertEquals("test...", StringHelper.getShortenedString("test string", 7));
  74     }
  75
  76     @Test
  77     public void isNotNullNotEmpty_should_return_true_if_string_is_not_null_or_not_empty(){
  78         assertFalse(StringHelper.isNotNullNotEmpty(null));
  79         assertFalse(StringHelper.isNotNullNotEmpty(""));
  80         assertFalse(StringHelper.isNotNullNotEmpty(" "));
  81         assertTrue(StringHelper.isNotNullNotEmpty("test"));
  82     }
  83
  84     @Test
  85     public void isNullOrEmpty_should_return_true_if_string_is_null_or_empty(){
  86         assertTrue(StringHelper.isNullOrEmpty(null));
  87         assertTrue(StringHelper.isNullOrEmpty(""));
  88         assertTrue(StringHelper.isNullOrEmpty(" "));
  89         assertFalse(StringHelper.isNullOrEmpty("test"));
  90     }
  91
  92     @Test
  93     public void areEqual_should_return_true_when_both_null(){
  94         assertTrue(StringHelper.areEqual(null, null));
  95     }
  96
  97     @Test
  98     public void areEqual_should_return_false_when_one_string_is_null(){
  99         assertFalse(StringHelper.areEqual(null, "test"));
 100     }
 101
 102     @Test
 103     public void areEqual_should_compare_two_string(){
 104         assertFalse(StringHelper.areEqual("test2", "test"));
 105         assertFalse(StringHelper.areEqual("test", "Test"));
 106     }
 107
 108     @Test
 109     public void equalsIgnoreCase_should_compare_two_string_case_insensitive(){
 110         assertFalse(StringHelper.equalsIgnoreCase("test2", "test"));
 111         assertTrue(StringHelper.equalsIgnoreCase("test", "Test"));
 112     }
 113
 114     @Test
 115     public void mangleName_should_pad_string_when_given_null_or_empty(){
 116         assertEquals("aaaa", StringHelper.mangleName(null, 3, 6));
 117         assertEquals("aaaa", StringHelper.mangleName(StringUtils.EMPTY, 3, 6));
 118
 119         assertEquals("aa", StringHelper.mangleName(null, 1, 6));
 120         assertEquals("aa", StringHelper.mangleName(StringUtils.EMPTY, 1, 6));
 121
 122         assertEquals("aaaaaaaaa", StringHelper.mangleName(null, 8, 12));
 123         assertEquals("aaaaaaaaa", StringHelper.mangleName(StringUtils.EMPTY, 8, 12));
 124
 125     }
 126
 127     @Test
 128     public void mangleName_should_remove_all_illegal_characters(){
 129         assertEquals("ab45", StringHelper.mangleName("ab45 ", 3, 6));
 130         assertEquals("ab45", StringHelper.mangleName("ab!45", 3, 6));
 131         assertEquals("ab45", StringHelper.mangleName("a b!45", 3, 6));
 132     }
 133
 134     @Test
 135     public void mangleName_should_convert_all_character_to_lowercase(){
 136         assertEquals("test", StringHelper.mangleName("TeSt", 3, 6));
 137         assertEquals("abb45fgr", StringHelper.mangleName("abB!4 5FGR", 6, 8));
 138     }
 139
 140     @Test
 141     public void mangleName_should_pad_string_when_result_is_too_short(){
 142         assertEquals("testaaa", StringHelper.mangleName("TeSt", 6, 10));
 143         assertEquals("abb45fgraaaaa", StringHelper.mangleName("abB!4 5FGR", 12, 15));
 144     }
 145
 146     @Test
 147     public void mangleName_should_truncate_string_when_too_long(){
 148         assertEquals("tst", StringHelper.mangleName("TeSt", 0, 3));
 149         assertEquals("tt", StringHelper.mangleName("TeSt", 0, 2));
 150         assertEquals("agr", StringHelper.mangleName("abb45fgr", 0, 3));
 151         assertEquals("abgr", StringHelper.mangleName("abb45fgr", 0, 4));
 152     }
 153
 154     @Test
 155     public void normalizeString_should_return_null_when_given_null_or_empty_string(){
 156         assertNull(StringHelper.normalizeString(null));
 157         assertNull(StringHelper.normalizeString(StringUtils.EMPTY));
 158     }
 159
 160     @Test
 161     public void normalizeString_should_trim_string(){
 162         assertEquals("this is test sequence",
 163             StringHelper.normalizeString("  this is test sequence "));
 164         assertEquals("this  is test   sequence",
 165             StringHelper.normalizeString("  this  is test   sequence   "));
 166     }
 167
 168     @Test
 169     public void stripCRLFs_should_return_null_when_given_null() {
 170         assertNull(StringHelper.stripCRLF(null));
 171     }
 172
 173     @Test
 174     public void stripCRLF_should_strip_all_CRLF_and_LF() {
 175         assertEquals(StringUtils.EMPTY, StringHelper.toUnixLines(StringUtils.EMPTY));
 176         assertEquals("this is test sequence", StringHelper.stripCRLF("this is test sequence"));
 177         assertEquals("this is testsequence", StringHelper.stripCRLF("this is test\nsequence"));
 178         assertEquals("this istestsequence", StringHelper.stripCRLF("this is\ntest\r\nsequence"));
 179         assertEquals("this istestsequence", StringHelper.stripCRLF("this is\r\ntest\n\rsequence"));
 180     }
 181
 182     @Test
 183     public void toDOSLines_should_return_null_when_given_null() {
 184         assertNull(StringHelper.toDOSLines(null));
 185     }
 186
 187     @Test
 188     public void toUnixLines_should_replace_LF_with_CRLF() {
 189         assertEquals(StringUtils.EMPTY, StringHelper.toUnixLines(StringUtils.EMPTY));
 190         assertEquals("this is test sequence", StringHelper.toDOSLines("this is test sequence"));
 191         assertEquals("this is test\r\nsequence", StringHelper.toDOSLines("this is test\nsequence"));
 192         assertEquals("this is test\rsequence", StringHelper.toDOSLines("this is test\rsequence"));
 193         assertEquals("this is\r\ntest\n\rsequence", StringHelper.toDOSLines("this is\r\ntest\n\rsequence"));
 194     }
 195
 196     @Test
 197     public void toUnixLines_should_return_null_when_given_null() {
 198         assertNull(StringHelper.toUnixLines(null));
 199     }
 200
 201     @Test
 202     public void toUnixLines_should_replace_CRLF_with_LF() {
 203         assertEquals(StringUtils.EMPTY, StringHelper.toUnixLines(StringUtils.EMPTY));
 204         assertEquals("this is test sequence", StringHelper.toUnixLines("this is test sequence"));
 205         assertEquals("this is test\nsequence", StringHelper.toUnixLines("this is test\nsequence"));
 206         assertEquals("this is\ntest\nsequence", StringHelper.toUnixLines("this is\r\ntest\n\rsequence"));
 207     }
 208
 209     @Test
 210     public void translate_should_return_null_when_given_null_sequence() {
 211         assertNull(StringHelper.translate(null, "abc", "def"));
 212     }
 213
 214     @Test
 215     public void translate_should_translate_sequence() {
 216
 217         assertEquals(StringUtils.EMPTY, StringHelper.translate(StringUtils.EMPTY, "abc", "def"));
 218         assertEquals("ahis is absa sbqubccb",
 219             StringHelper.translate("this is test sequence", "ten", "abc"));
 220     }
 221
 222
 223     @Test
 224     public void translate_should_translate_sequence_given_replacement_longer_then_match() {
 225         assertEquals("ahis is absa sbqubccb",
 226             StringHelper.translate("this is test sequence", "ten", "abcde"));
 227     }
 228
 229     @Test
 230     public void translate_should_translate_sequence_given_replacement_shorter_then_match() {
 231         assertEquals("ahas as absa sbqubccb",
 232             StringHelper.translate("this is test sequence", "teni", "abc"));
 233     }
 234
 235     @Test
 236     public void validIdentifier_should_return_null_when_given_null() {
 237         assertNull(StringHelper.validIdentifier(null));
 238     }
 239
 240
 241     @Test
 242     public void validIdentifier_should_return_valid_identifier() {
 243         assertEquals(StringUtils.EMPTY, StringHelper.validIdentifier(StringUtils.EMPTY));
 244         assertEquals("abcd", StringHelper.validIdentifier("abcd"));
 245         assertEquals("abc_", StringHelper.validIdentifier("abc!"));
 246         assertEquals("ab_cd", StringHelper.validIdentifier("ab cd"));
 247         assertEquals("ab_cd_", StringHelper.validIdentifier("ab cd!"));
 248     }
 249
 250     @Test
 251     public void verify_should_return_null_when_given_null_sequence() {
 252         assertNull(StringHelper.verify(null, "abc", 'r'));
 253     }
 254
 255     @Test
 256     public void verify_should_return_empty_string_when_given_empty_sequence() {
 257         assertEquals(StringUtils.EMPTY, StringHelper.verify("", "abc", 'r'));
 258     }
 259
 260     @Test
 261     public void verify_should_replace_illegal_characters() {
 262         assertEquals("trir ir tert rerterre",
 263             StringHelper.verify("this is test sentence", "iet ", 'r'));
 264     }
 265
 266     @Test
 267     public void toList_should_return_empty_string_when_given_null_or_empty_list() {
 268         assertEquals(StringUtils.EMPTY, StringHelper.asList((List<String>) null));
 269         assertEquals(StringUtils.EMPTY, StringHelper.asList((Lists.newArrayList())));
 270     }
 271
 272     @Test
 273     public void toList_should_return_element_when_given_one_element_list() {
 274         assertEquals("test", StringHelper.asList(Lists.newArrayList("test")));
 275     }
 276
 277     @Test
 278     public void toList_should_convert_to_string_given_list() {
 279         assertEquals("test, test2, test3",
 280             StringHelper.asList(Lists.newArrayList("test", "test2", "test3")));
 281     }
 282
 283     @Test
 284     public void toList_should_return_empty_string_when_given_null_or_empty_map() {
 285         assertEquals(StringUtils.EMPTY, StringHelper.asList((Map<String, String>) null));
 286         assertEquals(StringUtils.EMPTY, StringHelper.asList((Maps.newHashMap())));
 287     }
 288
 289     @Test
 290     public void toList_should_return_entry_when_given_one_entry_map() {
 291         Map<String, String> testMap = new HashMap<>();
 292         testMap.put("key1", "value1");
 293
 294         assertEquals("key1=value1", StringHelper.asList(testMap));
 295     }
 296
 297     @Test
 298     public void toList_should_convert_to_string_given_map() {
 299         Map<String, String> testMap = new HashMap<>();
 300         testMap.put("key1", "value1");
 301         testMap.put("key2", "value2");
 302
 303         assertEquals("key1=value1, key2=value2", StringHelper.asList(testMap));
 304     }
 305
 306     @Test
 307     public void toList_should_return_string_representation_of_empty_array_when_given_null() {
 308         String value = StringHelper.asList((String[]) null);
 309         assertNotNull(value);
 310         assertEquals("[]", value);
 311     }
 312
 313     @Test
 314     public void toList_should_return_string_representation_of_empty_array_when_given_empty_array() {
 315         String value = StringHelper.asList(new String[]{});
 316         assertNotNull(value);
 317         assertEquals("[]", value);
 318     }
 319
 320     @Test
 321     public void toList_should_return_string_representation_of_one_element_array() {
 322         String value = StringHelper.asList("one");
 323         assertNotNull(value);
 324         assertEquals("[one]", value);
 325     }
 326
 327     @Test
 328     public void toList_should_return_string_representation_of_array() {
 329         String value = StringHelper.asList("one", "two", "three", "four", "five");
 330         assertNotNull(value);
 331         assertEquals("[one,two,three,four,five]", value);
 332     }
 333
 334     @Test
 335     public void propertiesToString_should_return_null_when_given_null_properties() {
 336
 337         assertEquals(null, StringHelper.propertiesToString(null));
 338     }
 339
 340     @Test
 341     public void propertiesToString_should_return_string_representation_of_empty_array_when_given_empty_properties() {
 342
 343         Properties props = new Properties();
 344
 345         String result = StringHelper.propertiesToString(props);
 346         assertNotNull(result);
 347         assertEquals("[ ]", result);
 348     }
 349
 350     @Test
 351     public void propertiesToString_should_return_convert_properties_to_string() {
 352         Properties props = new Properties();
 353         props.setProperty("key1", "value1");
 354         props.setProperty("key2", "value2");
 355
 356         String result = StringHelper.propertiesToString(props);
 357
 358         assertTrue(result.startsWith("[ "));
 359         assertTrue(result.contains("key1"));
 360         assertTrue(result.contains("value1"));
 361         assertTrue(result.contains("key2"));
 362         assertTrue(result.contains("value2"));
 363         assertTrue(result.endsWith(" ]"));
 364         assertTrue(result.lastIndexOf(",") < result.length() - 3);
 365     }
 366 }