test_class.file: dubbo-common/src/test/java/com/alibaba/dubbo/common/utils/CompatibleTypeUtilsTest.java
test_class.identifier: CompatibleTypeUtilsTest
test_case.body: @SuppressWarnings("unchecked")
      @Test
      public void testCompatibleTypeConvert() throws Exception {
          Object result;
  
          {
              Object input = new Object();
              result = CompatibleTypeUtils.compatibleTypeConvert(input, Date.class);
              assertSame(input, result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(input, null);
              assertSame(input, result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(null, Date.class);
              assertNull(result);
          }
  
          {
              result = CompatibleTypeUtils.compatibleTypeConvert("a", char.class);
              assertEquals(Character.valueOf('a'), (Character) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert("A", MyEnum.class);
              assertEquals(MyEnum.A, (MyEnum) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert("3", BigInteger.class);
              assertEquals(new BigInteger("3"), (BigInteger) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert("3", BigDecimal.class);
              assertEquals(new BigDecimal("3"), (BigDecimal) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert("2011-12-11 12:24:12", Date.class);
              assertEquals(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2011-12-11 12:24:12"), (Date) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert("2011-12-11 12:24:12", java.sql.Date.class);
              assertEquals(new SimpleDateFormat("yyyy-MM-dd").format((java.sql.Date) result), "2011-12-11");
  
              result = CompatibleTypeUtils.compatibleTypeConvert("2011-12-11 12:24:12", java.sql.Time.class);
              assertEquals(new SimpleDateFormat("HH:mm:ss").format((java.sql.Time) result), "12:24:12");
  
              result = CompatibleTypeUtils.compatibleTypeConvert("2011-12-11 12:24:12", java.sql.Timestamp.class);
              assertEquals(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format((java.sql.Timestamp) result), "2011-12-11 12:24:12");
  
              result = CompatibleTypeUtils.compatibleTypeConvert("ab", char[].class);
              assertEquals(2, ((char[]) result).length);
              assertEquals('a', ((char[]) result)[0]);
              assertEquals('b', ((char[]) result)[1]);
  
              result = CompatibleTypeUtils.compatibleTypeConvert("", char[].class);
              assertEquals(0, ((char[]) result).length);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(null, char[].class);
              assertEquals(null, result);
          }
  
          {
              result = CompatibleTypeUtils.compatibleTypeConvert(3, byte.class);
              assertEquals(Byte.valueOf((byte) 3), (Byte) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert((byte) 3, int.class);
              assertEquals(Integer.valueOf(3), (Integer) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(3, short.class);
              assertEquals(Short.valueOf((short) 3), (Short) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert((short) 3, int.class);
              assertEquals(Integer.valueOf(3), (Integer) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(3, int.class);
              assertEquals(Integer.valueOf(3), (Integer) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(3, long.class);
              assertEquals(Long.valueOf(3), (Long) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(3L, int.class);
              assertEquals(Integer.valueOf(3), (Integer) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(3L, BigInteger.class);
              assertEquals(BigInteger.valueOf(3L), (BigInteger) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(BigInteger.valueOf(3L), int.class);
              assertEquals(Integer.valueOf(3), (Integer) result);
          }
  
          {
              result = CompatibleTypeUtils.compatibleTypeConvert(3D, float.class);
              assertEquals(Float.valueOf(3), (Float) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(3F, double.class);
              assertEquals(Double.valueOf(3), (Double) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(3D, double.class);
              assertEquals(Double.valueOf(3), (Double) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(3D, BigDecimal.class);
              assertEquals(BigDecimal.valueOf(3D), (BigDecimal) result);
  
              result = CompatibleTypeUtils.compatibleTypeConvert(BigDecimal.valueOf(3D), double.class);
              assertEquals(Double.valueOf(3), (Double) result);
          }
  
          {
              List<String> list = new ArrayList<String>();
              list.add("a");
              list.add("b");
  
              Set<String> set = new HashSet<String>();
              set.add("a");
              set.add("b");
  
              String[] array = new String[]{"a", "b"};
  
              result = CompatibleTypeUtils.compatibleTypeConvert(array, List.class);
              assertEquals(ArrayList.class, result.getClass());
              assertEquals(2, ((List<String>) result).size());
              assertTrue(((List<String>) result).contains("a"));
              assertTrue(((List<String>) result).contains("b"));
  
              result = CompatibleTypeUtils.compatibleTypeConvert(set, List.class);
              assertEquals(ArrayList.class, result.getClass());
              assertEquals(2, ((List<String>) result).size());
              assertTrue(((List<String>) result).contains("a"));
              assertTrue(((List<String>) result).contains("b"));
  
              result = CompatibleTypeUtils.compatibleTypeConvert(array, CopyOnWriteArrayList.class);
              assertEquals(CopyOnWriteArrayList.class, result.getClass());
              assertEquals(2, ((List<String>) result).size());
              assertTrue(((List<String>) result).contains("a"));
              assertTrue(((List<String>) result).contains("b"));
  
              result = CompatibleTypeUtils.compatibleTypeConvert(set, CopyOnWriteArrayList.class);
              assertEquals(CopyOnWriteArrayList.class, result.getClass());
              assertEquals(2, ((List<String>) result).size());
              assertTrue(((List<String>) result).contains("a"));
              assertTrue(((List<String>) result).contains("b"));
  
              result = CompatibleTypeUtils.compatibleTypeConvert(set, String[].class);
              assertEquals(String[].class, result.getClass());
              assertEquals(2, ((String[]) result).length);
              assertTrue(((String[]) result)[0].equals("a") || ((String[]) result)[0].equals("b"));
              assertTrue(((String[]) result)[1].equals("a") || ((String[]) result)[1].equals("b"));
  
              result = CompatibleTypeUtils.compatibleTypeConvert(array, Set.class);
              assertEquals(HashSet.class, result.getClass());
              assertEquals(2, ((Set<String>) result).size());
              assertTrue(((Set<String>) result).contains("a"));
              assertTrue(((Set<String>) result).contains("b"));
  
              result = CompatibleTypeUtils.compatibleTypeConvert(list, Set.class);
              assertEquals(HashSet.class, result.getClass());
              assertEquals(2, ((Set<String>) result).size());
              assertTrue(((Set<String>) result).contains("a"));
              assertTrue(((Set<String>) result).contains("b"));
  
              result = CompatibleTypeUtils.compatibleTypeConvert(array, ConcurrentHashSet.class);
              assertEquals(ConcurrentHashSet.class, result.getClass());
              assertEquals(2, ((Set<String>) result).size());
              assertTrue(((Set<String>) result).contains("a"));
              assertTrue(((Set<String>) result).contains("b"));
  
              result = CompatibleTypeUtils.compatibleTypeConvert(list, ConcurrentHashSet.class);
              assertEquals(ConcurrentHashSet.class, result.getClass());
              assertEquals(2, ((Set<String>) result).size());
              assertTrue(((Set<String>) result).contains("a"));
              assertTrue(((Set<String>) result).contains("b"));
  
              result = CompatibleTypeUtils.compatibleTypeConvert(list, String[].class);
              assertEquals(String[].class, result.getClass());
              assertEquals(2, ((String[]) result).length);
              assertTrue(((String[]) result)[0].equals("a"));
              assertTrue(((String[]) result)[1].equals("b"));
  
          }
  
      }
test_case.class_method_signature: CompatibleTypeUtilsTest.testCompatibleTypeConvert()
test_case.full_signature: @SuppressWarnings("unchecked") @Test public void testCompatibleTypeConvert()
test_case.identifier: testCompatibleTypeConvert
test_case.invocations: compatibleTypeConvert assertSame compatibleTypeConvert assertSame compatibleTypeConvert assertNull compatibleTypeConvert assertEquals valueOf compatibleTypeConvert assertEquals compatibleTypeConvert assertEquals compatibleTypeConvert assertEquals compatibleTypeConvert assertEquals parse compatibleTypeConvert assertEquals format compatibleTypeConvert assertEquals format compatibleTypeConvert assertEquals format compatibleTypeConvert assertEquals assertEquals assertEquals compatibleTypeConvert assertEquals compatibleTypeConvert assertEquals compatibleTypeConvert assertEquals valueOf compatibleTypeConvert assertEquals valueOf compatibleTypeConvert assertEquals valueOf compatibleTypeConvert assertEquals valueOf compatibleTypeConvert assertEquals valueOf compatibleTypeConvert assertEquals valueOf compatibleTypeConvert assertEquals valueOf compatibleTypeConvert assertEquals valueOf compatibleTypeConvert valueOf assertEquals valueOf compatibleTypeConvert assertEquals valueOf compatibleTypeConvert assertEquals valueOf compatibleTypeConvert assertEquals valueOf compatibleTypeConvert assertEquals valueOf compatibleTypeConvert valueOf assertEquals valueOf add add add add compatibleTypeConvert assertEquals getClass assertEquals size assertTrue contains assertTrue contains compatibleTypeConvert assertEquals getClass assertEquals size assertTrue contains assertTrue contains compatibleTypeConvert assertEquals getClass assertEquals size assertTrue contains assertTrue contains compatibleTypeConvert assertEquals getClass assertEquals size assertTrue contains assertTrue contains compatibleTypeConvert assertEquals getClass assertEquals assertTrue equals equals assertTrue equals equals compatibleTypeConvert assertEquals getClass assertEquals size assertTrue contains assertTrue contains compatibleTypeConvert assertEquals getClass assertEquals size assertTrue contains assertTrue contains compatibleTypeConvert assertEquals getClass assertEquals size assertTrue contains assertTrue contains compatibleTypeConvert assertEquals getClass assertEquals size assertTrue contains assertTrue contains compatibleTypeConvert assertEquals getClass assertEquals assertTrue equals assertTrue equals
test_case.modifiers: @SuppressWarnings("unchecked") @Test public
test_case.parameters: ()
test_case.return: void
test_case.signature: void testCompatibleTypeConvert()
focal_class.declarator: DATE_FORMAT = "yyyy-MM-dd HH:mm:ss"
focal_class.modifier: private static final
focal_class.original_string: private static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
focal_class.type: String
focal_class.var_name: DATE_FORMAT
focal_class.file: dubbo-common/src/main/java/com/alibaba/dubbo/common/utils/CompatibleTypeUtils.java
focal_class.identifier: CompatibleTypeUtils
focal_class.class_method_signature: CompatibleTypeUtils.CompatibleTypeUtils()
focal_class.full_signature: private  CompatibleTypeUtils()
focal_class.identifier: CompatibleTypeUtils
focal_class.modifiers: private
focal_class.parameters: ()
focal_class.signature:  CompatibleTypeUtils()
focal_class.class_method_signature: CompatibleTypeUtils.compatibleTypeConvert(Object value, Class<?> type)
focal_class.full_signature: @SuppressWarnings({"unchecked", "rawtypes"}) public static Object compatibleTypeConvert(Object value, Class<?> type)
focal_class.identifier: compatibleTypeConvert
focal_class.modifiers: @SuppressWarnings({"unchecked", "rawtypes"}) public static
focal_class.parameters: (Object value, Class<?> type)
focal_class.return: Object
focal_class.signature: Object compatibleTypeConvert(Object value, Class<?> type)
focal_method.body: @SuppressWarnings({"unchecked", "rawtypes"})
      public static Object compatibleTypeConvert(Object value, Class<?> type) {
          if (value == null || type == null || type.isAssignableFrom(value.getClass())) {
              return value;
          }
          if (value instanceof String) {
              String string = (String) value;
              if (char.class.equals(type) || Character.class.equals(type)) {
                  if (string.length() != 1) {
                      throw new IllegalArgumentException(String.format("CAN NOT convert String(%s) to char!" +
                              " when convert String to char, the String MUST only 1 char.", string));
                  }
                  return string.charAt(0);
              } else if (type.isEnum()) {
                  return Enum.valueOf((Class<Enum>) type, string);
              } else if (type == BigInteger.class) {
                  return new BigInteger(string);
              } else if (type == BigDecimal.class) {
                  return new BigDecimal(string);
              } else if (type == Short.class || type == short.class) {
                  return new Short(string);
              } else if (type == Integer.class || type == int.class) {
                  return new Integer(string);
              } else if (type == Long.class || type == long.class) {
                  return new Long(string);
              } else if (type == Double.class || type == double.class) {
                  return new Double(string);
              } else if (type == Float.class || type == float.class) {
                  return new Float(string);
              } else if (type == Byte.class || type == byte.class) {
                  return new Byte(string);
              } else if (type == Boolean.class || type == boolean.class) {
                  return new Boolean(string);
              } else if (type == Date.class || type == java.sql.Date.class || type == java.sql.Timestamp.class || type == java.sql.Time.class) {
                  try {
                      Date date = new SimpleDateFormat(DATE_FORMAT).parse((String) value);
                      if (type == java.sql.Date.class) {
                          return new java.sql.Date(date.getTime());
                      } else if (type == java.sql.Timestamp.class) {
                          return new java.sql.Timestamp(date.getTime());
                      } else if (type == java.sql.Time.class) {
                          return new java.sql.Time(date.getTime());
                      } else {
                          return date;
                      }
                  } catch (ParseException e) {
                      throw new IllegalStateException("Failed to parse date " + value + " by format " + DATE_FORMAT + ", cause: " + e.getMessage(), e);
                  }
              } else if (type == Class.class) {
                  try {
                      return ReflectUtils.name2class((String) value);
                  } catch (ClassNotFoundException e) {
                      throw new RuntimeException(e.getMessage(), e);
                  }
              } else if (char[].class.equals(type)) {
                  // Process string to char array for generic invoke
                  // See
                  // - https://github.com/apache/incubator-dubbo/issues/2003
                  if (string == null) {
                      return null;
                  }
                  else {
                      int len = string.length();
                      char[] chars = new char[len];
                      string.getChars(0, len, chars, 0);
                      return chars;
                  }
              }
          } else if (value instanceof Number) {
              Number number = (Number) value;
              if (type == byte.class || type == Byte.class) {
                  return number.byteValue();
              } else if (type == short.class || type == Short.class) {
                  return number.shortValue();
              } else if (type == int.class || type == Integer.class) {
                  return number.intValue();
              } else if (type == long.class || type == Long.class) {
                  return number.longValue();
              } else if (type == float.class || type == Float.class) {
                  return number.floatValue();
              } else if (type == double.class || type == Double.class) {
                  return number.doubleValue();
              } else if (type == BigInteger.class) {
                  return BigInteger.valueOf(number.longValue());
              } else if (type == BigDecimal.class) {
                  return BigDecimal.valueOf(number.doubleValue());
              } else if (type == Date.class) {
                  return new Date(number.longValue());
              }
          } else if (value instanceof Collection) {
              Collection collection = (Collection) value;
              if (type.isArray()) {
                  int length = collection.size();
                  Object array = Array.newInstance(type.getComponentType(), length);
                  int i = 0;
                  for (Object item : collection) {
                      Array.set(array, i++, item);
                  }
                  return array;
              } else if (!type.isInterface()) {
                  try {
                      Collection result = (Collection) type.newInstance();
                      result.addAll(collection);
                      return result;
                  } catch (Throwable e) {
                  }
              } else if (type == List.class) {
                  return new ArrayList<Object>(collection);
              } else if (type == Set.class) {
                  return new HashSet<Object>(collection);
              }
          } else if (value.getClass().isArray() && Collection.class.isAssignableFrom(type)) {
              Collection collection;
              if (!type.isInterface()) {
                  try {
                      collection = (Collection) type.newInstance();
                  } catch (Throwable e) {
                      collection = new ArrayList<Object>();
                  }
              } else if (type == Set.class) {
                  collection = new HashSet<Object>();
              } else {
                  collection = new ArrayList<Object>();
              }
              int length = Array.getLength(value);
              for (int i = 0; i < length; i++) {
                  collection.add(Array.get(value, i));
              }
              return collection;
          }
          return value;
      }
focal_method.class_method_signature: CompatibleTypeUtils.compatibleTypeConvert(Object value, Class<?> type)
focal_method.full_signature: @SuppressWarnings({"unchecked", "rawtypes"}) public static Object compatibleTypeConvert(Object value, Class<?> type)
focal_method.identifier: compatibleTypeConvert
focal_method.invocations: isAssignableFrom getClass equals equals length format charAt isEnum valueOf parse getTime getTime getTime getMessage name2class getMessage equals length getChars byteValue shortValue intValue longValue floatValue doubleValue valueOf longValue valueOf doubleValue longValue isArray size newInstance getComponentType set isInterface newInstance addAll isArray getClass isAssignableFrom isInterface newInstance getLength add get
focal_method.modifiers: @SuppressWarnings({"unchecked", "rawtypes"}) public static
focal_method.parameters: (Object value, Class<?> type)
focal_method.return: Object
focal_method.signature: Object compatibleTypeConvert(Object value, Class<?> type)