Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: DeviceEnrollmentDenialListOptions extends ListOptions { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!super.equals(obj)) { return false; } if (!(obj instanceof DeviceEnrollmentDenialListOptions)) { return false; } final DeviceEnrollmentDenialListOptions other = (DeviceEnrollmentDenialListOptions) obj; if (!other.canEqual(this)) { return false; } return true; } @Internal DeviceEnrollmentDenialListOptions(Integer pageSize, Long maxResults, Order order, String after, List<IncludeField> include, Filters filter); @Internal DeviceEnrollmentDenialListOptions(DeviceEnrollmentDenialListOptions deviceEnrollmentDenialListOptions); DeviceEnrollmentDenialListOptions(); @Internal DeviceEnrollmentDenialListOptions(String after, Filters filter); List<Filter> getEndpointNameFilters(); void addEqualToEndpointNameFilter(String filterByEndpointName); @SuppressWarnings("unchecked") T equalToEndpointName(String filterByEndpointName); List<Filter> getTrustedCertificateIdFilters(); void addEqualToTrustedCertificateIdFilter(String filterByTrustedCertificateId); @SuppressWarnings("unchecked") T equalToTrustedCertificateId(String filterByTrustedCertificateId); @Override String toString(); @Override DeviceEnrollmentDenialListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); static final String TAG_FILTER_BY_ENDPOINT_NAME; static final String TAG_FILTER_BY_TRUSTED_CERTIFICATE_ID; }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { DeviceEnrollmentDenialListOptions deviceenrollmentdeniallistoptions1 = new DeviceEnrollmentDenialListOptions(Integer.valueOf(-17), Long.valueOf(88), Order.getDefault(), "ee45108b-af62-408c-a753-8dbb4b592e5d", null, null); DeviceEnrollmentDenialListOptions deviceenrollmentdeniallistoptions2 = new DeviceEnrollmentDenialListOptions(Integer.valueOf(-17), Long.valueOf(88), Order.getDefault(), "ee45108b-af62-408c-a753-8dbb4b592e5d", null, null); DeviceEnrollmentDenialListOptions deviceenrollmentdeniallistoptions3 = new DeviceEnrollmentDenialListOptions(Integer.valueOf(-75), Long.valueOf(99), Order.getDefault(), "00b78c67-aa72-403f-b666-9b9d060ac9ee", null, null); assertNotNull(deviceenrollmentdeniallistoptions1); assertNotNull(deviceenrollmentdeniallistoptions2); assertNotNull(deviceenrollmentdeniallistoptions3); assertNotSame(deviceenrollmentdeniallistoptions2, deviceenrollmentdeniallistoptions1); assertNotSame(deviceenrollmentdeniallistoptions3, deviceenrollmentdeniallistoptions1); assertEquals(deviceenrollmentdeniallistoptions2, deviceenrollmentdeniallistoptions1); assertEquals(deviceenrollmentdeniallistoptions2, deviceenrollmentdeniallistoptions1); assertEquals(deviceenrollmentdeniallistoptions1, deviceenrollmentdeniallistoptions2); assertEquals(deviceenrollmentdeniallistoptions1, deviceenrollmentdeniallistoptions1); assertFalse(deviceenrollmentdeniallistoptions1.equals(null)); assertNotEquals(deviceenrollmentdeniallistoptions3, deviceenrollmentdeniallistoptions1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: ApiUtils { public static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart) { return SdkUtils.convertSnakeToCamel(stringToConvert, capitalAtStart); } private ApiUtils(); static void checkNotNull(SdkLogger logger, Object arg, String argName); static void checkModelValidity(SdkLogger logger, SdkModel model, String argName); static boolean isCloudException(Throwable exception); static boolean isNotImplementedException(Throwable exception); static boolean isParameterErrorException(Throwable exception); static String normalisePath(String path); static String normaliseResourcePath(String resourcePath); static boolean comparePaths(String path1, String path2); static String toUtcTimestamp(Date date); static Date convertStringToDate(String valueStr); static String convertCamelToSnake(String stringToConvert); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static URLConnection openConnection(@NonNull URL url, @Nullable ApiClientWrapper client, @NonNull SdkLogger logger); }### Answer: @Test public final void testConvertSnakeToCamel() { String testfunctionString = "this_is_a_function_name"; String testClassString = "this_is_a_class_name"; assertEquals("thisIsAFunctionName", ApiUtils.convertSnakeToCamel(testfunctionString, false)); assertEquals("ThisIsAClassName", ApiUtils.convertSnakeToCamel(testClassString, true)); assertEquals(null, ApiUtils.convertSnakeToCamel(null, true)); assertEquals("", ApiUtils.convertSnakeToCamel("", true)); assertEquals("ThisIsAClassName", ApiUtils.convertSnakeToCamel("ThisIsAClassName", true)); assertEquals("thisIsAFunctionName", ApiUtils.convertSnakeToCamel("thisIsAFunctionName", false)); }
### Question: DeviceEnrollmentListOptions extends ListOptions { @Override public DeviceEnrollmentListOptions clone() { final DeviceEnrollmentListOptions opt = new DeviceEnrollmentListOptions(); opt.setOptions(this); return opt; } @Internal DeviceEnrollmentListOptions(Integer pageSize, Long maxResults, Order order, String after, List<IncludeField> include, Filters filter); @Internal DeviceEnrollmentListOptions(DeviceEnrollmentListOptions deviceEnrollmentListOptions); DeviceEnrollmentListOptions(); @Internal DeviceEnrollmentListOptions(String after, Filters filter); @Override String toString(); @Override DeviceEnrollmentListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { DeviceEnrollmentListOptions deviceenrollmentlistoptions1 = new DeviceEnrollmentListOptions(Integer.valueOf(-101), Long.valueOf(126), Order.getDefault(), "ebb30e09-5650-4c47-b79c-4e0585db44ef", null, null); DeviceEnrollmentListOptions deviceenrollmentlistoptions2 = deviceenrollmentlistoptions1.clone(); assertNotNull(deviceenrollmentlistoptions1); assertNotNull(deviceenrollmentlistoptions2); assertNotSame(deviceenrollmentlistoptions2, deviceenrollmentlistoptions1); assertEquals(deviceenrollmentlistoptions2, deviceenrollmentlistoptions1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DeviceEnrollmentListOptions extends ListOptions { @Override @SuppressWarnings("PMD.UselessOverridingMethod") public int hashCode() { return super.hashCode(); } @Internal DeviceEnrollmentListOptions(Integer pageSize, Long maxResults, Order order, String after, List<IncludeField> include, Filters filter); @Internal DeviceEnrollmentListOptions(DeviceEnrollmentListOptions deviceEnrollmentListOptions); DeviceEnrollmentListOptions(); @Internal DeviceEnrollmentListOptions(String after, Filters filter); @Override String toString(); @Override DeviceEnrollmentListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { DeviceEnrollmentListOptions deviceenrollmentlistoptions1 = new DeviceEnrollmentListOptions(Integer.valueOf(62), Long.valueOf(-82), Order.getDefault(), "5a4aee78-89ab-46dd-aa20-2d301bf69576", null, null); DeviceEnrollmentListOptions deviceenrollmentlistoptions2 = new DeviceEnrollmentListOptions(Integer.valueOf(62), Long.valueOf(-82), Order.getDefault(), "5a4aee78-89ab-46dd-aa20-2d301bf69576", null, null); assertNotNull(deviceenrollmentlistoptions1); assertNotNull(deviceenrollmentlistoptions2); assertNotSame(deviceenrollmentlistoptions2, deviceenrollmentlistoptions1); assertEquals(deviceenrollmentlistoptions2, deviceenrollmentlistoptions1); assertEquals(deviceenrollmentlistoptions2.hashCode(), deviceenrollmentlistoptions1.hashCode()); int hashCode = deviceenrollmentlistoptions1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, deviceenrollmentlistoptions1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DeviceEnrollmentListOptions extends ListOptions { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!super.equals(obj)) { return false; } if (!(obj instanceof DeviceEnrollmentListOptions)) { return false; } final DeviceEnrollmentListOptions other = (DeviceEnrollmentListOptions) obj; if (!other.canEqual(this)) { return false; } return true; } @Internal DeviceEnrollmentListOptions(Integer pageSize, Long maxResults, Order order, String after, List<IncludeField> include, Filters filter); @Internal DeviceEnrollmentListOptions(DeviceEnrollmentListOptions deviceEnrollmentListOptions); DeviceEnrollmentListOptions(); @Internal DeviceEnrollmentListOptions(String after, Filters filter); @Override String toString(); @Override DeviceEnrollmentListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { DeviceEnrollmentListOptions deviceenrollmentlistoptions1 = new DeviceEnrollmentListOptions(Integer.valueOf(125), Long.valueOf(58), Order.getDefault(), "8722d407-24aa-440e-b6bf-ec0bcd746b5e", null, null); DeviceEnrollmentListOptions deviceenrollmentlistoptions2 = new DeviceEnrollmentListOptions(Integer.valueOf(125), Long.valueOf(58), Order.getDefault(), "8722d407-24aa-440e-b6bf-ec0bcd746b5e", null, null); DeviceEnrollmentListOptions deviceenrollmentlistoptions3 = new DeviceEnrollmentListOptions(Integer.valueOf(-85), Long.valueOf(-55), Order.getDefault(), "322171ef-d1b3-4480-9657-ac953a9ab4b1", null, null); assertNotNull(deviceenrollmentlistoptions1); assertNotNull(deviceenrollmentlistoptions2); assertNotNull(deviceenrollmentlistoptions3); assertNotSame(deviceenrollmentlistoptions2, deviceenrollmentlistoptions1); assertNotSame(deviceenrollmentlistoptions3, deviceenrollmentlistoptions1); assertEquals(deviceenrollmentlistoptions2, deviceenrollmentlistoptions1); assertEquals(deviceenrollmentlistoptions2, deviceenrollmentlistoptions1); assertEquals(deviceenrollmentlistoptions1, deviceenrollmentlistoptions2); assertEquals(deviceenrollmentlistoptions1, deviceenrollmentlistoptions1); assertFalse(deviceenrollmentlistoptions1.equals(null)); assertNotEquals(deviceenrollmentlistoptions3, deviceenrollmentlistoptions1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DeviceGroupListDao extends AbstractModelListDao<DeviceGroup, DeviceGroupListOptions> implements ModelListDao<DeviceGroup, DeviceGroupListOptions> { @Override @SuppressWarnings({ "resource", "unused" }) public DeviceGroupListDao clone() { try { return new DeviceGroupListDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } DeviceGroupListDao(); DeviceGroupListDao(ApiClientWrapper client); DeviceGroupListDao(ConnectionOptions options); DeviceGroupListDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) DeviceGroupListDao clone(); @Override @Internal @SuppressWarnings("unchecked") Class<DeviceGroupDao> getModelDaoClass(); @Override @Internal @SuppressWarnings({ "unchecked", "resource" }) DeviceGroupDao getNewModelDao(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { DeviceGroupListDao devicegrouplistdao1 = new DeviceGroupListDao(); DeviceGroupListDao devicegrouplistdao2 = devicegrouplistdao1.clone(); assertNotNull(devicegrouplistdao1); assertNotNull(devicegrouplistdao2); assertNotSame(devicegrouplistdao2, devicegrouplistdao1); assertEquals(devicegrouplistdao2, devicegrouplistdao1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DeviceEnrollmentBulkDeleteDao extends AbstractDeviceEnrollmentBulkDeleteDao { @SuppressWarnings("resource") @Override public DeviceEnrollmentBulkDeleteDao clone() { try { return new DeviceEnrollmentBulkDeleteDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (@SuppressWarnings("unused") MbedCloudException exception) { return null; } } DeviceEnrollmentBulkDeleteDao(); @NonNull FileDownload downloadErrorsReportFile(@NonNull DeviceEnrollmentBulkDelete model, @Nullable File destination); @NonNull FileDownload downloadErrorsReportFile(@NonNull DeviceEnrollmentBulkDelete model, @Nullable String filePath); @NonNull FileDownload downloadErrorsReportFile(@NonNull DeviceEnrollmentBulkDelete model); @NonNull FileDownload downloadErrorsReportFile(@Nullable File destination); @NonNull FileDownload downloadErrorsReportFile(@Nullable String filePath); FileDownload downloadFullReportFile(@NonNull DeviceEnrollmentBulkDelete model, File destination); FileDownload downloadFullReportFile(@NonNull DeviceEnrollmentBulkDelete model, String filePath); FileDownload downloadFullReportFile(@NonNull DeviceEnrollmentBulkDelete model); FileDownload downloadFullReportFile(File destination); FileDownload downloadFullReportFile(String filePath); @NotImplemented @Override void delete(String id); @NotImplemented @Override void delete(DeviceEnrollmentBulkDelete modelToDelete); @NotImplemented @Override void delete(); @SuppressWarnings("resource") @Override DeviceEnrollmentBulkDeleteDao clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { DeviceEnrollmentBulkDeleteDao deviceenrollmentbulkdeletedao1 = new DeviceEnrollmentBulkDeleteDao(); DeviceEnrollmentBulkDeleteDao deviceenrollmentbulkdeletedao2 = deviceenrollmentbulkdeletedao1.clone(); assertNotNull(deviceenrollmentbulkdeletedao1); assertNotNull(deviceenrollmentbulkdeletedao2); assertNotSame(deviceenrollmentbulkdeletedao2, deviceenrollmentbulkdeletedao1); assertEquals(deviceenrollmentbulkdeletedao2, deviceenrollmentbulkdeletedao1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DeviceDao extends AbstractModelDao<Device> implements CrudDao<Device> { @Override @SuppressWarnings({ "resource", "unused" }) public DeviceDao clone() { try { return new DeviceDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } DeviceDao(); DeviceDao(ApiClientWrapper client); DeviceDao(ConnectionOptions options); DeviceDao(SdkContext sdkContext); void addToGroup(@NonNull String deviceGroupId); void addToGroup(@NonNull String deviceGroupId, @NonNull Device device); @Override @SuppressWarnings({ "resource", "unused" }) DeviceDao clone(); @Override Device create(); @Override Device create(@NonNull Device device); @Override void delete(); @Override void delete(@NonNull Device device); @Override void delete(@NonNull String id); @Override Device read(); Device read(@NonNull Device device); @Override Device read(@NonNull String id); void removeFromGroup(@NonNull String deviceGroupId); void removeFromGroup(@NonNull String deviceGroupId, @NonNull Device device); CertificateEnrollment renewCertificate(@NonNull String certificateName); CertificateEnrollment renewCertificate(@NonNull String certificateName, @NonNull Device device); CertificateEnrollment renewCertificate(@NonNull String certificateName, @NonNull String id); @Override Device update(); @Override Device update(@NonNull Device device); Device update(@NonNull String id); Device update(@NonNull String id, @NonNull Device device); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { DeviceDao devicedao1 = new DeviceDao(); DeviceDao devicedao2 = devicedao1.clone(); assertNotNull(devicedao1); assertNotNull(devicedao2); assertNotSame(devicedao2, devicedao1); assertEquals(devicedao2, devicedao1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: ApiUtils { public static String convertCamelToSnake(String stringToConvert) { return SdkUtils.convertCamelToSnake(stringToConvert); } private ApiUtils(); static void checkNotNull(SdkLogger logger, Object arg, String argName); static void checkModelValidity(SdkLogger logger, SdkModel model, String argName); static boolean isCloudException(Throwable exception); static boolean isNotImplementedException(Throwable exception); static boolean isParameterErrorException(Throwable exception); static String normalisePath(String path); static String normaliseResourcePath(String resourcePath); static boolean comparePaths(String path1, String path2); static String toUtcTimestamp(Date date); static Date convertStringToDate(String valueStr); static String convertCamelToSnake(String stringToConvert); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static URLConnection openConnection(@NonNull URL url, @Nullable ApiClientWrapper client, @NonNull SdkLogger logger); }### Answer: @Test public final void testConvertCamelToSnake() { String testfunctionString = "thisIsAFunctionName"; String testClassString = "ThisIsAClassName"; String testMalformedFunctionString = "Device_Event_retrieve"; assertEquals("this_is_a_function_name", ApiUtils.convertCamelToSnake(testfunctionString)); assertEquals("this_is_a_class_name", ApiUtils.convertCamelToSnake(testClassString)); assertEquals("device_event_retrieve", ApiUtils.convertCamelToSnake(testMalformedFunctionString)); assertEquals("", ApiUtils.convertCamelToSnake("")); assertNull(ApiUtils.convertCamelToSnake(null)); assertEquals("this_is_a_class_name", ApiUtils.convertCamelToSnake("this_is_a_class_name")); }
### Question: Base64Decoder { public static String decodeToUTF8(ByteBuffer input) { if (input == null) { return null; } return new String(decode(input).array(), StandardCharsets.UTF_8); } Base64Decoder(); static List<?> decodeBase64Lwm2m(ByteBuffer buffer, EncodingType contentType); static List<T> decodeBase64Lwm2m(ByteBuffer buffer, Class<T> clazz, EncodingType contentType); static ByteBuffer decode(ByteBuffer input); static String decodeToUTF8(ByteBuffer input); static ByteBuffer decode(String input); static String decodeToUtf8(String input); }### Answer: @Test public void testDecodeString() { assertEquals("This is a test for decoding base64 encoded strings", Base64Decoder.decodeToUtf8("VGhpcyBpcyBhIHRlc3QgZm9yIGRlY29kaW5nIGJhc2U2NCBlbmNvZGVkIHN0cmluZ3M=")); }
### Question: SdkUtils { public static List<String> parseListString(String listString) { if (listString == null) { return null; } if (listString.isEmpty()) { return new ArrayList<>(); } final Matcher matcher = JSON_ARRAY_PATTERN.matcher(listString); String[] array = null; if (matcher.matches()) { final String aliasArray = matcher.group(1); array = aliasArray.replaceAll("[\'\"]", "").split(","); } else { array = listString.split(","); } return Arrays.asList(array); } private SdkUtils(); static List<String> parseListString(String listString); static String joinList(List<?> list, String separator); static boolean urlEquals(URL url1, URL url2); static int urlHashcode(URL url); static String toHex(byte[] value); static String checkModelValidity(SdkModel model, String argName); static String describeRequiredFields(SdkModel model); static @NonNull List<Field> listRequiredFields(@Nullable SdkModel model); static @NonNull List<Field> determineMissingFields(@Nullable SdkModel model); static StringBuilder generateInvalidModelInstanceErrorMessage(SdkModel model, String argName); @SuppressWarnings("PMD.NPathComplexity") static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argType, String argName); static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argName); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static String convertCamelToSnake(String stringToConvert); static CaseConverter getCaseConverter(CaseConversion conversion); static boolean hasExtension(String fileName); static String getFileExtension(String fileName); static String getFileNameWithoutExtension(String fileName); static final String EXTENSION_SEPARATOR; }### Answer: @Test public void testParseListString() { assertNull(SdkUtils.parseListString(null)); assertArrayEquals(new ArrayList<>().toArray(), SdkUtils.parseListString("").toArray()); final List<String> list = Arrays.asList("1", "2", "3", "4"); final String csv = SdkUtils.joinList(list, ","); final String jsonArray = "[\"1\",\"2\",\"3\",\"4\"]"; assertArrayEquals(list.toArray(), SdkUtils.parseListString(csv).toArray()); assertArrayEquals(list.toArray(), SdkUtils.parseListString(jsonArray).toArray()); }
### Question: SdkUtils { public static String joinList(List<?> list, String separator) { if (list == null \|\| list.isEmpty()) { return null; } final StringBuilder buffer = new StringBuilder(); boolean start = true; for (final Object element : list) { if (!start) { buffer.append(separator); } buffer.append(toSting(element)); start = false; } return buffer.toString(); } private SdkUtils(); static List<String> parseListString(String listString); static String joinList(List<?> list, String separator); static boolean urlEquals(URL url1, URL url2); static int urlHashcode(URL url); static String toHex(byte[] value); static String checkModelValidity(SdkModel model, String argName); static String describeRequiredFields(SdkModel model); static @NonNull List<Field> listRequiredFields(@Nullable SdkModel model); static @NonNull List<Field> determineMissingFields(@Nullable SdkModel model); static StringBuilder generateInvalidModelInstanceErrorMessage(SdkModel model, String argName); @SuppressWarnings("PMD.NPathComplexity") static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argType, String argName); static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argName); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static String convertCamelToSnake(String stringToConvert); static CaseConverter getCaseConverter(CaseConversion conversion); static boolean hasExtension(String fileName); static String getFileExtension(String fileName); static String getFileNameWithoutExtension(String fileName); static final String EXTENSION_SEPARATOR; }### Answer: @Test public void testJoinList() { assertNull(SdkUtils.joinList(null, "")); assertNull(SdkUtils.joinList(new ArrayList<>(), "")); final List<String> list = Arrays.asList("1", "2", "3", "4"); final String separator = "+-/+_$£&^%!()(&^"; assertEquals(String.join(separator, list), SdkUtils.joinList(list, separator)); final List<EnumTestClass> listEnum = Arrays.asList(EnumTestClass.VALUE1, EnumTestClass.VALUE2); final String enumCsv = SdkUtils.joinList(listEnum, ","); assertEquals("value1,value2", enumCsv); final List<ModelTestClass> listModel = Arrays.asList(new ModelTestClass("test1", null), new ModelTestClass("test2", null)); final String modelCsv = SdkUtils.joinList(listModel, ","); assertEquals("test1,test2", modelCsv); }
### Question: SdkUtils { public static boolean urlEquals(URL url1, URL url2) { if (url1 == null && url2 == null) { return true; } if (url1 == null \|\| url2 == null) { return false; } if (url1.toString() == null) { return url2.toString() == null; } return url1.toString().equals(url2.toString()); } private SdkUtils(); static List<String> parseListString(String listString); static String joinList(List<?> list, String separator); static boolean urlEquals(URL url1, URL url2); static int urlHashcode(URL url); static String toHex(byte[] value); static String checkModelValidity(SdkModel model, String argName); static String describeRequiredFields(SdkModel model); static @NonNull List<Field> listRequiredFields(@Nullable SdkModel model); static @NonNull List<Field> determineMissingFields(@Nullable SdkModel model); static StringBuilder generateInvalidModelInstanceErrorMessage(SdkModel model, String argName); @SuppressWarnings("PMD.NPathComplexity") static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argType, String argName); static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argName); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static String convertCamelToSnake(String stringToConvert); static CaseConverter getCaseConverter(CaseConversion conversion); static boolean hasExtension(String fileName); static String getFileExtension(String fileName); static String getFileNameWithoutExtension(String fileName); static final String EXTENSION_SEPARATOR; }### Answer: @Test public void testUrlEquals() { try { assertTrue(SdkUtils.urlEquals(null, null)); URL url = new URL("http: assertFalse(SdkUtils.urlEquals(null, url)); assertFalse(SdkUtils.urlEquals(url, null)); assertTrue(SdkUtils.urlEquals(url, url)); assertTrue(SdkUtils.urlEquals(url, new URL("http: assertTrue(SdkUtils.urlEquals(new URL("http: assertFalse(SdkUtils.urlEquals(new URL("http: } catch (MalformedURLException exception) { fail(exception.getMessage()); } }
### Question: SdkUtils { public static String toHex(byte[] value) { if (value == null) { return null; } return Hex.encodeHexString(value); } private SdkUtils(); static List<String> parseListString(String listString); static String joinList(List<?> list, String separator); static boolean urlEquals(URL url1, URL url2); static int urlHashcode(URL url); static String toHex(byte[] value); static String checkModelValidity(SdkModel model, String argName); static String describeRequiredFields(SdkModel model); static @NonNull List<Field> listRequiredFields(@Nullable SdkModel model); static @NonNull List<Field> determineMissingFields(@Nullable SdkModel model); static StringBuilder generateInvalidModelInstanceErrorMessage(SdkModel model, String argName); @SuppressWarnings("PMD.NPathComplexity") static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argType, String argName); static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argName); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static String convertCamelToSnake(String stringToConvert); static CaseConverter getCaseConverter(CaseConversion conversion); static boolean hasExtension(String fileName); static String getFileExtension(String fileName); static String getFileNameWithoutExtension(String fileName); static final String EXTENSION_SEPARATOR; }### Answer: @Test public void testHexArray() { assertNull(SdkUtils.toHex(null)); byte[] value = { (byte) 255, (byte) 255 }; assertEquals("ffff", SdkUtils.toHex(value)); }
### Question: SdkUtils { public static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart) { if (stringToConvert == null \|\| stringToConvert.isEmpty()) { return stringToConvert; } final StringBuffer sb = new StringBuffer(); boolean start = true; final String[] stringElements = stringToConvert.replace(DOUBLE_UNDERSCORE, UNDERSCORE).split(UNDERSCORE); final int numberOfElements = stringElements.length; for (final String s : stringElements) { if (start) { sb.append(capitalAtStart ? Character.toUpperCase(s.charAt(0)) : Character.toLowerCase(s.charAt(0))); start = false; } else { sb.append(Character.toUpperCase(s.charAt(0))); } if (s.length() > 1) { String subString = s.substring(1, s.length()); if (numberOfElements > 1) { subString = subString.toLowerCase(Locale.getDefault()); } sb.append(subString); } } return sb.toString(); } private SdkUtils(); static List<String> parseListString(String listString); static String joinList(List<?> list, String separator); static boolean urlEquals(URL url1, URL url2); static int urlHashcode(URL url); static String toHex(byte[] value); static String checkModelValidity(SdkModel model, String argName); static String describeRequiredFields(SdkModel model); static @NonNull List<Field> listRequiredFields(@Nullable SdkModel model); static @NonNull List<Field> determineMissingFields(@Nullable SdkModel model); static StringBuilder generateInvalidModelInstanceErrorMessage(SdkModel model, String argName); @SuppressWarnings("PMD.NPathComplexity") static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argType, String argName); static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argName); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static String convertCamelToSnake(String stringToConvert); static CaseConverter getCaseConverter(CaseConversion conversion); static boolean hasExtension(String fileName); static String getFileExtension(String fileName); static String getFileNameWithoutExtension(String fileName); static final String EXTENSION_SEPARATOR; }### Answer: @Test public final void testConvertSnakeToCamel() { String testfunctionString = "this_is_a_function_name"; String testClassString = "this_is_a_class_name"; assertEquals("thisIsAFunctionName", SdkUtils.convertSnakeToCamel(testfunctionString, false)); assertEquals("ThisIsAClassName", SdkUtils.convertSnakeToCamel(testClassString, true)); assertEquals(null, SdkUtils.convertSnakeToCamel(null, true)); assertEquals("", SdkUtils.convertSnakeToCamel("", true)); assertEquals("ThisIsAClassName", SdkUtils.convertSnakeToCamel("ThisIsAClassName", true)); assertEquals("thisIsAFunctionName", SdkUtils.convertSnakeToCamel("thisIsAFunctionName", false)); }
### Question: SdkUtils { public static String convertCamelToSnake(String stringToConvert) { if (stringToConvert == null \|\| stringToConvert.isEmpty()) { return stringToConvert; } return stringToConvert.trim().replaceAll("(.)(\\p{Upper})", "$1_$2") .replaceAll("(\\p{Upper})(\\p{Upper})", "$1_$2").replace(WHITE_SPACE, UNDERSCORE) .replace(DOUBLE_UNDERSCORE, UNDERSCORE).toLowerCase(Locale.UK).trim(); } private SdkUtils(); static List<String> parseListString(String listString); static String joinList(List<?> list, String separator); static boolean urlEquals(URL url1, URL url2); static int urlHashcode(URL url); static String toHex(byte[] value); static String checkModelValidity(SdkModel model, String argName); static String describeRequiredFields(SdkModel model); static @NonNull List<Field> listRequiredFields(@Nullable SdkModel model); static @NonNull List<Field> determineMissingFields(@Nullable SdkModel model); static StringBuilder generateInvalidModelInstanceErrorMessage(SdkModel model, String argName); @SuppressWarnings("PMD.NPathComplexity") static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argType, String argName); static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argName); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static String convertCamelToSnake(String stringToConvert); static CaseConverter getCaseConverter(CaseConversion conversion); static boolean hasExtension(String fileName); static String getFileExtension(String fileName); static String getFileNameWithoutExtension(String fileName); static final String EXTENSION_SEPARATOR; }### Answer: @Test public final void testConvertCamelToSnake() { String testfunctionString = "thisIsAFunctionName"; String testClassString = "ThisIsAClassName"; String testMalformedFunctionString = "Device_Event_retrieve"; assertEquals("this_is_a_function_name", SdkUtils.convertCamelToSnake(testfunctionString)); assertEquals("this_is_a_function_name", SdkUtils.convertCamelToSnake(" " + testfunctionString + " ")); assertEquals("this_is_a_class_name", SdkUtils.convertCamelToSnake(testClassString)); assertEquals("device_event_retrieve", SdkUtils.convertCamelToSnake(testMalformedFunctionString)); assertEquals("", SdkUtils.convertCamelToSnake("")); assertNull(SdkUtils.convertCamelToSnake(null)); assertEquals("this_is_a_class_name", SdkUtils.convertCamelToSnake("this_is_a_class_name")); assertEquals("this_is_a_function_name", SdkUtils.convertCamelToSnake("thisIs A FunctionName")); }
### Question: SdkUtils { public static CaseConverter getCaseConverter(CaseConversion conversion) { CaseConverter converter = null; switch (conversion) { case CAMEL_TO_SNAKE: converter = new CaseConverter() { @Override public String convert(String strToConvert, boolean capitalAtStart) { return convertCamelToSnake(strToConvert); } }; break; case SNAKE_TO_CAMEL: converter = new CaseConverter() { @Override public String convert(String strToConvert, boolean capitalAtStart) { return convertSnakeToCamel(strToConvert, capitalAtStart); } }; break; default: break; } return converter; } private SdkUtils(); static List<String> parseListString(String listString); static String joinList(List<?> list, String separator); static boolean urlEquals(URL url1, URL url2); static int urlHashcode(URL url); static String toHex(byte[] value); static String checkModelValidity(SdkModel model, String argName); static String describeRequiredFields(SdkModel model); static @NonNull List<Field> listRequiredFields(@Nullable SdkModel model); static @NonNull List<Field> determineMissingFields(@Nullable SdkModel model); static StringBuilder generateInvalidModelInstanceErrorMessage(SdkModel model, String argName); @SuppressWarnings("PMD.NPathComplexity") static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argType, String argName); static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argName); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static String convertCamelToSnake(String stringToConvert); static CaseConverter getCaseConverter(CaseConversion conversion); static boolean hasExtension(String fileName); static String getFileExtension(String fileName); static String getFileNameWithoutExtension(String fileName); static final String EXTENSION_SEPARATOR; }### Answer: @Test public final void testGetCaseConverter() { String testfunctionString = "thisIsAFunctionName"; String testClassString = "ThisIsAClassName"; String tempText = SdkUtils.getCaseConverter(CaseConversion.CAMEL_TO_SNAKE).convert(testfunctionString, false); assertNotNull(tempText); assertNotEquals(testfunctionString, tempText); assertEquals(testfunctionString, SdkUtils.getCaseConverter(CaseConversion.SNAKE_TO_CAMEL).convert(tempText, false)); tempText = SdkUtils.getCaseConverter(CaseConversion.CAMEL_TO_SNAKE).convert(testClassString, true); assertNotNull(tempText); assertNotEquals(testClassString, tempText); assertEquals(testClassString, SdkUtils.getCaseConverter(CaseConversion.SNAKE_TO_CAMEL).convert(tempText, true)); }
### Question: SdkUtils { public static String describeRequiredFields(SdkModel model) { return generateModelInstanceRequiredFieldsMessage(model, listRequiredFields(model), "model", model == null ? SdkModel.class.getSimpleName() : model.getClass().getSimpleName()).toString(); } private SdkUtils(); static List<String> parseListString(String listString); static String joinList(List<?> list, String separator); static boolean urlEquals(URL url1, URL url2); static int urlHashcode(URL url); static String toHex(byte[] value); static String checkModelValidity(SdkModel model, String argName); static String describeRequiredFields(SdkModel model); static @NonNull List<Field> listRequiredFields(@Nullable SdkModel model); static @NonNull List<Field> determineMissingFields(@Nullable SdkModel model); static StringBuilder generateInvalidModelInstanceErrorMessage(SdkModel model, String argName); @SuppressWarnings("PMD.NPathComplexity") static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argType, String argName); static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argName); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static String convertCamelToSnake(String stringToConvert); static CaseConverter getCaseConverter(CaseConversion conversion); static boolean hasExtension(String fileName); static String getFileExtension(String fileName); static String getFileNameWithoutExtension(String fileName); static final String EXTENSION_SEPARATOR; }### Answer: @Test public final void testRequiredFieldMessage() { ModelTestClass model = new ModelTestClass(); String message = SdkUtils.describeRequiredFields(model); assertNotNull(message); assertTrue(message.contains("fieldRequired")); assertTrue(message.contains("setFieldRequired")); assertFalse(message.contains("fieldNotRequired")); assertFalse(message.contains("setFieldNotRequired")); }
### Question: ApiUtils { public static String normalisePath(String path) { if (path != null && !path.isEmpty() && path.charAt(0) == '/') { return path.substring(1); } return path; } private ApiUtils(); static void checkNotNull(SdkLogger logger, Object arg, String argName); static void checkModelValidity(SdkLogger logger, SdkModel model, String argName); static boolean isCloudException(Throwable exception); static boolean isNotImplementedException(Throwable exception); static boolean isParameterErrorException(Throwable exception); static String normalisePath(String path); static String normaliseResourcePath(String resourcePath); static boolean comparePaths(String path1, String path2); static String toUtcTimestamp(Date date); static Date convertStringToDate(String valueStr); static String convertCamelToSnake(String stringToConvert); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static URLConnection openConnection(@NonNull URL url, @Nullable ApiClientWrapper client, @NonNull SdkLogger logger); }### Answer: @Test public final void testNormalisePath() { assertNull(ApiUtils.normalisePath(null)); assertTrue(ApiUtils.normalisePath("").isEmpty()); assertTrue(ApiUtils.normalisePath("/").isEmpty()); String path = "test/path"; assertEquals(path, ApiUtils.normalisePath(path)); String path2 = "/" + path; assertEquals(path, ApiUtils.normalisePath(path2)); }
### Question: SdkUtils { public static String checkModelValidity(SdkModel model, String argName) { if (model == null) { return null; } if (model.isValid()) { return null; } final List<Field> missingFields = determineMissingFields(model); final StringBuilder errorBuilder = missingFields.isEmpty() ? SdkUtils.generateInvalidModelInstanceErrorMessage(model, argName) : SdkUtils.generateModelInstanceRequiredFieldsMessage(model, missingFields, argName); return errorBuilder.toString(); } private SdkUtils(); static List<String> parseListString(String listString); static String joinList(List<?> list, String separator); static boolean urlEquals(URL url1, URL url2); static int urlHashcode(URL url); static String toHex(byte[] value); static String checkModelValidity(SdkModel model, String argName); static String describeRequiredFields(SdkModel model); static @NonNull List<Field> listRequiredFields(@Nullable SdkModel model); static @NonNull List<Field> determineMissingFields(@Nullable SdkModel model); static StringBuilder generateInvalidModelInstanceErrorMessage(SdkModel model, String argName); @SuppressWarnings("PMD.NPathComplexity") static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argType, String argName); static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argName); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static String convertCamelToSnake(String stringToConvert); static CaseConverter getCaseConverter(CaseConversion conversion); static boolean hasExtension(String fileName); static String getFileExtension(String fileName); static String getFileNameWithoutExtension(String fileName); static final String EXTENSION_SEPARATOR; }### Answer: @Test public final void testCheckModelValidity() { ModelTestClass model = new ModelTestClass(); String message = SdkUtils.checkModelValidity(model, "some model"); assertNotNull(message); assertTrue(message.contains("fieldRequired")); assertTrue(message.contains("setFieldRequired")); assertFalse(message.contains("fieldNotRequired")); assertFalse(message.contains("setFieldNotRequired")); model = new ModelTestClass(null, "some message"); message = SdkUtils.checkModelValidity(model, "some model"); assertNotNull(message); assertTrue(message.contains("fieldRequired")); assertTrue(message.contains("setFieldRequired")); assertFalse(message.contains("fieldNotRequired")); assertFalse(message.contains("setFieldNotRequired")); model = new ModelTestClass("some required message", null); message = SdkUtils.checkModelValidity(model, "some model"); assertNull(message); }
### Question: SdkUtils { public static String getFileExtension(String fileName) { if (fileName == null \|\| fileName.trim().endsWith(EXTENSION_SEPARATOR)) { return EMPTY_STRING; } final int i = fileName.lastIndexOf('.'); if (i < 0) { return EMPTY_STRING; } final StringBuilder builder = new StringBuilder(); final String shorterFilename = fileName.substring(0, i); final int j = shorterFilename.lastIndexOf('.'); if (j > 0 && shorterFilename.length() - j < 5) { builder.append(shorterFilename.substring(j + 1)).append('.'); } builder.append(fileName.substring(i + 1)); return builder.toString().trim(); } private SdkUtils(); static List<String> parseListString(String listString); static String joinList(List<?> list, String separator); static boolean urlEquals(URL url1, URL url2); static int urlHashcode(URL url); static String toHex(byte[] value); static String checkModelValidity(SdkModel model, String argName); static String describeRequiredFields(SdkModel model); static @NonNull List<Field> listRequiredFields(@Nullable SdkModel model); static @NonNull List<Field> determineMissingFields(@Nullable SdkModel model); static StringBuilder generateInvalidModelInstanceErrorMessage(SdkModel model, String argName); @SuppressWarnings("PMD.NPathComplexity") static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argType, String argName); static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argName); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static String convertCamelToSnake(String stringToConvert); static CaseConverter getCaseConverter(CaseConversion conversion); static boolean hasExtension(String fileName); static String getFileExtension(String fileName); static String getFileNameWithoutExtension(String fileName); static final String EXTENSION_SEPARATOR; }### Answer: @Test public void testGetFileExtension() { String filePath = "201806-0157528bb84102420a01321400000000-activedevices.098052628912094123.gz"; assertEquals("gz", SdkUtils.getFileExtension(filePath)); assertTrue(SdkUtils.hasExtension(filePath)); filePath = "C:\\Users\\adrcab01\\AppData\\Local\\Temp\\201806-0157528bb84102420a01321400000000-activedevices.5098052628912094123.7z"; assertEquals("7z", SdkUtils.getFileExtension(filePath)); assertTrue(SdkUtils.hasExtension(filePath)); filePath = "https: assertEquals("csv.gz", SdkUtils.getFileExtension(filePath)); assertTrue(SdkUtils.hasExtension(filePath)); filePath = "201806-0157528bb84102420a01321400000000-activedevices.098052628912094123."; assertEquals("", SdkUtils.getFileExtension(filePath)); assertFalse(SdkUtils.hasExtension(filePath)); filePath = "C:\\Users\\adrcab01\\AppData\\Local\\Temp\\201806-0157528bb84102420a01321400000000-activedevices.5098052628912094123.7z "; assertEquals("7z", SdkUtils.getFileExtension(filePath)); assertTrue(SdkUtils.hasExtension(filePath)); }
### Question: SdkUtils { public static String getFileNameWithoutExtension(String fileName) { if (fileName == null) { return EMPTY_STRING; } return fileName.trim().replace(EXTENSION_SEPARATOR + getFileExtension(fileName), EMPTY_STRING); } private SdkUtils(); static List<String> parseListString(String listString); static String joinList(List<?> list, String separator); static boolean urlEquals(URL url1, URL url2); static int urlHashcode(URL url); static String toHex(byte[] value); static String checkModelValidity(SdkModel model, String argName); static String describeRequiredFields(SdkModel model); static @NonNull List<Field> listRequiredFields(@Nullable SdkModel model); static @NonNull List<Field> determineMissingFields(@Nullable SdkModel model); static StringBuilder generateInvalidModelInstanceErrorMessage(SdkModel model, String argName); @SuppressWarnings("PMD.NPathComplexity") static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argType, String argName); static StringBuilder generateModelInstanceRequiredFieldsMessage(SdkModel model, List<Field> requiredFields, String argName); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static String convertCamelToSnake(String stringToConvert); static CaseConverter getCaseConverter(CaseConversion conversion); static boolean hasExtension(String fileName); static String getFileExtension(String fileName); static String getFileNameWithoutExtension(String fileName); static final String EXTENSION_SEPARATOR; }### Answer: @Test public void testGetFileNameWithoutExtension() { String filePath = "201806-0157528bb84102420a01321400000000-activedevices.098052628912094123.gz"; assertEquals("201806-0157528bb84102420a01321400000000-activedevices.098052628912094123", SdkUtils.getFileNameWithoutExtension(filePath)); filePath = "201806-0157528bb84102420a01321400000000-activedevices.5098052628912094123.7z"; assertEquals("201806-0157528bb84102420a01321400000000-activedevices.5098052628912094123", SdkUtils.getFileNameWithoutExtension(filePath)); filePath = "201806-0157528bb84102420a01321400000000-firmwareupdates.csv.gz"; assertEquals("201806-0157528bb84102420a01321400000000-firmwareupdates", SdkUtils.getFileNameWithoutExtension(filePath)); filePath = "201806-0157528bb84102420a01321400000000-firmwareupdates .csv.gz "; assertEquals("201806-0157528bb84102420a01321400000000-firmwareupdates ", SdkUtils.getFileNameWithoutExtension(filePath)); }
### Question: Error implements SdkModel { @Override public Error clone() { return new Error(object, code, type, message, requestId, fields); } Error(); Error(int code, String type, String message, String requestId); Error(String object, int code, String type, String message, String requestId, List<Field> fields); String getObject(); void setObject(String object); int getCode(); void setCode(int code); String getType(); void setType(String type); String getMessage(); void setMessage(String message); String getRequestId(); void setRequestId(String requestId); List<Field> getFields(); void setFields(List<Field> fields); @Override String toString(); String toPrettyString(); @Override final int hashCode(); @Override final boolean equals(Object obj); @Override Error clone(); @Override boolean isValid(); @Override String getId(); @Override void setId(String id); }### Answer: @Test public void testClone() { Error error = new Error(205, "some type", "some message", "requestId_10"); Error clone = error.clone(); assertNotSame(error, clone); assertEquals(error, clone); }
### Question: DataFile implements SdkModel { public String getContentType() { return contentType; } DataFile(); DataFile(String contentType, File file); DataFile(File file); DataFile(String filePath); @Override String getId(); @PerformsNoOperation @Internal @Override void setId(String id); String getContentType(); @Required void setContentType(String contentType); File getFile(); @Nullable String getFileName(); boolean hasFile(); @Required void setFile(File file); boolean exists(); @Nullable String getMd5Checksum(); @Nullable String getSha1Checksum(); @Nullable String getSha256Checksum(); @Nullable String getSha512Checksum(); @Override DataFile clone(); @Override boolean isValid(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static final String BINARY_FILE_MEDIA_TYPE; static final String CSV_FILE_MEDIA_TYPE; static final String TEXT_FILE_MEDIA_TYPE; static final String GIF_IMAGE_FILE_MEDIA_TYPE; static final String PNG_IMAGE_FILE_MEDIA_TYPE; static final String JPEG_IMAGE_FILE_MEDIA_TYPE; static final String BMP_IMAGE_FILE_MEDIA_TYPE; }### Answer: @Test public void checkContentType() { DataFile file = new DataFile(new File("test.csv")); assertEquals(DataFile.CSV_FILE_MEDIA_TYPE, file.getContentType()); file = new DataFile(new File("test.txt")); assertEquals(DataFile.TEXT_FILE_MEDIA_TYPE, file.getContentType()); file = new DataFile(new File("test.png")); assertEquals(DataFile.PNG_IMAGE_FILE_MEDIA_TYPE, file.getContentType()); file = new DataFile(new File("test.jpeg")); assertEquals(DataFile.JPEG_IMAGE_FILE_MEDIA_TYPE, file.getContentType()); file = new DataFile(new File("test.csv.test")); assertEquals(DataFile.BINARY_FILE_MEDIA_TYPE, file.getContentType()); }
### Question: TimePeriod implements Cloneable, Serializable { @Override public String toString() { if (unit == null \|\| duration == 0) { setTimePeriod(DEFAULT_DURATION, DEFAULT_UNIT); } final StringBuilder builder = new StringBuilder(); switch (unit) { case DAYS: toStringAsDays(builder); break; case HOURS: toStringAsHours(builder); break; case MINUTES: toStringAsMinutes(builder); break; case NANOSECONDS: toStringAsNanoSeconds(builder); break; case SECONDS: toStringAsSeconds(builder); break; default: break; } return builder.toString(); } TimePeriod(TimeUnit unit, long duration); TimePeriod(long duration); TimePeriod(); TimePeriod(String value); static TimePeriod newTimePeriod(long duration); static TimePeriod newTimePeriod(String value); TimeUnit getUnit(); void setUnit(TimeUnit unit); long getDuration(); void setDuration(long duration); void setTimeout(long timeout); @Override String toString(); void fromString(String value); @Override TimePeriod clone(); @Override int hashCode(); @Override boolean equals(Object obj); int toSeconds(); }### Answer: @Test public void testToString() { TimePeriod period = new TimePeriod(); assertEquals("1d", period.toString()); period.setDuration(3); period.setUnit(TimeUnit.MINUTES); assertEquals("3m", period.toString()); period.setDuration(100); period.setUnit(TimeUnit.HOURS); assertEquals("100h", period.toString()); period.setDuration(14); period.setUnit(TimeUnit.DAYS); assertEquals("2w", period.toString()); period.setDuration(15); period.setUnit(TimeUnit.DAYS); assertEquals("15d", period.toString()); assertEquals("15d", TimePeriod.newTimePeriod("15d").toString()); assertEquals("15s", TimePeriod.newTimePeriod(15).toString()); }
### Question: TimePeriod implements Cloneable, Serializable { public void fromString(String value) { setTimePeriod(DEFAULT_DURATION, DEFAULT_UNIT); if (value == null \|\| value.isEmpty()) { return; } final Matcher matcher = STRING_PATTERN.matcher(value); if (matcher.matches()) { setTimePeriod(Long.parseLong(matcher.group(1)), getUnitFromChar(matcher.group(2))); } } TimePeriod(TimeUnit unit, long duration); TimePeriod(long duration); TimePeriod(); TimePeriod(String value); static TimePeriod newTimePeriod(long duration); static TimePeriod newTimePeriod(String value); TimeUnit getUnit(); void setUnit(TimeUnit unit); long getDuration(); void setDuration(long duration); void setTimeout(long timeout); @Override String toString(); void fromString(String value); @Override TimePeriod clone(); @Override int hashCode(); @Override boolean equals(Object obj); int toSeconds(); }### Answer: @Test public void testFromString() { TimePeriod period = new TimePeriod(); assertEquals("1d", period.toString()); period.fromString("3m"); assertEquals(TimeUnit.MINUTES, period.getUnit()); assertEquals(3, period.getDuration()); period = new TimePeriod("100h"); assertEquals(TimeUnit.HOURS, period.getUnit()); assertEquals(100, period.getDuration()); period.fromString(" 1000 s "); assertEquals(TimeUnit.SECONDS, period.getUnit()); assertEquals(1000, period.getDuration()); assertEquals("1000s", period.toString()); period = new TimePeriod("2w"); assertEquals(TimeUnit.DAYS, period.getUnit()); assertEquals(14, period.getDuration()); assertEquals("2w", period.toString()); period = new TimePeriod("1y"); assertEquals(TimeUnit.DAYS, period.getUnit()); assertEquals(366, period.getDuration()); assertEquals("1y", period.toString()); }
### Question: TimePeriod implements Cloneable, Serializable { @Override public TimePeriod clone() { return new TimePeriod(unit, duration); } TimePeriod(TimeUnit unit, long duration); TimePeriod(long duration); TimePeriod(); TimePeriod(String value); static TimePeriod newTimePeriod(long duration); static TimePeriod newTimePeriod(String value); TimeUnit getUnit(); void setUnit(TimeUnit unit); long getDuration(); void setDuration(long duration); void setTimeout(long timeout); @Override String toString(); void fromString(String value); @Override TimePeriod clone(); @Override int hashCode(); @Override boolean equals(Object obj); int toSeconds(); }### Answer: @Test public void testClone() { final TimePeriod p = new TimePeriod("1000n"); final TimePeriod clone = p.clone(); assertNotSame(p, clone); assertEquals(p, clone); assertEquals(TimeUnit.NANOSECONDS, clone.getUnit()); }
### Question: UuidGenerator { public static String generate() { return UUID.randomUUID().toString(); } private UuidGenerator(); static String generate(); }### Answer: @Test public void testGenerate() { final String uuid1 = UuidGenerator.generate(); final String uuid2 = UuidGenerator.generate(); assertNotNull(uuid1); assertNotNull(uuid2); assertFalse(uuid1.isEmpty()); assertFalse(uuid2.isEmpty()); assertNotEquals(uuid2, uuid1); }
### Question: Websocket implements SdkModel { @Override public Websocket clone() { return new Websocket(id, queueSize, status); } @Internal Websocket(String id, int queueSize, WebsocketStatus status); Websocket(); @Override String getId(); @Override void setId(String id); int getQueueSize(); WebsocketStatus getStatus(); @Override Websocket clone(); @Override boolean isValid(); @SuppressWarnings("boxing") @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testClone() { Websocket model = new Websocket("anID", 100, WebsocketStatus.DISCONNECTED); Websocket clone = model.clone(); assertNotSame(model, clone); assertEquals(model, clone); }
### Question: ApiUtils { public static String normaliseResourcePath(String resourcePath) { if (resourcePath != null && (resourcePath.isEmpty() \|\| resourcePath.charAt(0) != '/')) { return "/" + resourcePath; } return resourcePath; } private ApiUtils(); static void checkNotNull(SdkLogger logger, Object arg, String argName); static void checkModelValidity(SdkLogger logger, SdkModel model, String argName); static boolean isCloudException(Throwable exception); static boolean isNotImplementedException(Throwable exception); static boolean isParameterErrorException(Throwable exception); static String normalisePath(String path); static String normaliseResourcePath(String resourcePath); static boolean comparePaths(String path1, String path2); static String toUtcTimestamp(Date date); static Date convertStringToDate(String valueStr); static String convertCamelToSnake(String stringToConvert); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static URLConnection openConnection(@NonNull URL url, @Nullable ApiClientWrapper client, @NonNull SdkLogger logger); }### Answer: @Test public final void testNormaliseResourcePath() { assertNull(ApiUtils.normaliseResourcePath(null)); assertTrue(ApiUtils.normaliseResourcePath("").equals("/")); assertTrue(ApiUtils.normaliseResourcePath("/").equals("/")); String path = "test/path"; assertNotEquals(path, ApiUtils.normaliseResourcePath(path)); String path2 = "/" + path; assertEquals(path2, ApiUtils.normaliseResourcePath(path2)); }
### Question: Presubscription implements SdkModel { @Override public Presubscription clone() { return new Presubscription(deviceId, deviceType, resourcePaths); } Presubscription(String deviceId, String deviceType, List<String> resourcePaths); Presubscription(Device device, List<String> resourcePaths); Presubscription(Resource resource); Presubscription(); String getDeviceId(); void setDeviceId(String deviceId); Presubscription deviceId(String id); @Internal @Override String getId(); @PerformsNoOperation @Internal @Override void setId(String id); String getDeviceType(); void setDeviceType(String deviceType); List<String> getResourcePaths(); void setResourcePaths(List<String> resourcePaths); void addResourcePath(String resourcePath); void addResource(Resource resource); void setResources(List<Resource> resources); @Override Presubscription clone(); @Override boolean isValid(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); static final Presubscription TO_EVERYTHING; }### Answer: @Test public void testClone() { Presubscription model = new Presubscription(new Resource("deviceId", "resourcePath")); Presubscription clone = model.clone(); assertNotSame(model, clone); assertEquals(model, clone); }
### Question: Subscription implements SdkModel { @Override public Subscription clone() { return new Subscription(deviceId, resourcePaths); } Subscription(String deviceId, List<String> resourcePaths); Subscription(Resource resource); Subscription(); String getDeviceId(); void setDeviceId(String deviceId); List<String> getResourcePaths(); void setResourcePaths(List<String> resourcePaths); @Override Subscription clone(); @Override boolean isValid(); @Override String toString(); @Override String getId(); @Override void setId(String id); @Override int hashCode(); @Override boolean equals(Object obj); }### Answer: @Test public void testClone() { Subscription model = new Subscription(new Resource("deviceId", "resourcePath")); Subscription clone = model.clone(); assertNotSame(model, clone); assertEquals(model, clone); }
### Question: Resource implements SdkModel { @Override public Resource clone() { return new Resource(deviceId, path, resourceType, contentType, observable, interfaceDescription); } @Internal Resource(String deviceId, String path, String resourceType, String contentType, boolean observable, String interfaceDescription); @Internal Resource(String deviceId, String path, String resourceType, String contentType); Resource(String deviceId, String path); Resource(Device device, String path); Resource(); static Resource newObservableResource(String deviceId, String path); static Resource newObservableResource(Device device, String path); String getDeviceId(); @Internal @Override String getId(); @PerformsNoOperation @Internal @Override void setId(String id); @Required void setDeviceId(String deviceId); String getPath(); @Required void setPath(String path); @Internal void setResourcePath(String path); @Deprecated String getType(); String getResourceType(); String getContentType(); boolean isObservable(); String getInterfaceDescription(); @Override Resource clone(); @Override boolean isValid(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testClone() { Resource model = new Resource("deviceId", "resourcePath"); Resource clone = model.clone(); assertNotSame(model, clone); assertEquals(model, clone); }
### Question: Webhook implements SdkModel { @Override public Webhook clone() { return new Webhook(url, headers); } Webhook(URL url, Map<String, String> headers); Webhook(); Webhook(URL url); @Internal @Override String getId(); @PerformsNoOperation @Internal @Override void setId(String id); URL getUrl(); @Required void setUrl(URL url); Map<String, String> getHeaders(); void setHeaders(Map<String, String> headers); void addHeader(String key, String value); @Override Webhook clone(); @Override boolean isValid(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testClone() { try { Webhook model = new Webhook(new URL("http: Webhook clone = model.clone(); assertNotSame(model, clone); assertEquals(model, clone); } catch (MalformedURLException exception) { exception.printStackTrace(); fail(exception.getMessage()); } }
### Question: CertificateIssuerConfig implements SdkModel { @Override public CertificateIssuerConfig clone() { return new CertificateIssuerConfig(this); } @Internal CertificateIssuerConfig(String certificateIssuerId, Date createdAt, String id, String reference, Date updatedAt); @Internal CertificateIssuerConfig(CertificateIssuerConfig certificateIssuerConfig); CertificateIssuerConfig(); CertificateIssuerConfig(String id); @Internal CertificateIssuerConfig(Date createdAt, Date updatedAt); CertificateIssuerConfig(String certificateIssuerId, String reference); String getCertificateIssuerId(); @Required void setCertificateIssuerId(String certificateIssuerId); @SuppressWarnings("PMD.UselessParentheses") boolean isCertificateIssuerIdValid(); Date getCreatedAt(); @Override String getId(); @Override void setId(String id); @Internal void setCertificateIssuerConfigId(String certificateIssuerConfigId); String getReference(); @Required void setReference(String reference); @SuppressWarnings("PMD.UselessParentheses") boolean isReferenceValid(); Date getUpdatedAt(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override CertificateIssuerConfig clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { CertificateIssuerConfig certificateissuerconfig1 = new CertificateIssuerConfig("412591b4-5c5a-46e4-8239-130a76e959e4", new Date(1574704662122L), "bb3de966-6e76-43fc-a114-816f65fd551f", "d5d860e3-27c8-49e8-a338-6c54e45e4540", new Date(1574704661418L)); CertificateIssuerConfig certificateissuerconfig2 = certificateissuerconfig1.clone(); assertNotNull(certificateissuerconfig1); assertNotNull(certificateissuerconfig2); assertNotSame(certificateissuerconfig2, certificateissuerconfig1); assertEquals(certificateissuerconfig2, certificateissuerconfig1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: CertificateIssuerConfig implements SdkModel { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((certificateIssuerId == null) ? 0 : certificateIssuerId.hashCode()); result = prime * result + ((createdAt == null) ? 0 : createdAt.hashCode()); result = prime * result + ((id == null) ? 0 : id.hashCode()); result = prime * result + ((reference == null) ? 0 : reference.hashCode()); result = prime * result + ((updatedAt == null) ? 0 : updatedAt.hashCode()); return result; } @Internal CertificateIssuerConfig(String certificateIssuerId, Date createdAt, String id, String reference, Date updatedAt); @Internal CertificateIssuerConfig(CertificateIssuerConfig certificateIssuerConfig); CertificateIssuerConfig(); CertificateIssuerConfig(String id); @Internal CertificateIssuerConfig(Date createdAt, Date updatedAt); CertificateIssuerConfig(String certificateIssuerId, String reference); String getCertificateIssuerId(); @Required void setCertificateIssuerId(String certificateIssuerId); @SuppressWarnings("PMD.UselessParentheses") boolean isCertificateIssuerIdValid(); Date getCreatedAt(); @Override String getId(); @Override void setId(String id); @Internal void setCertificateIssuerConfigId(String certificateIssuerConfigId); String getReference(); @Required void setReference(String reference); @SuppressWarnings("PMD.UselessParentheses") boolean isReferenceValid(); Date getUpdatedAt(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override CertificateIssuerConfig clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { CertificateIssuerConfig certificateissuerconfig1 = new CertificateIssuerConfig("a5b43081-d1ee-4bca-94c7-2a74f48169d1", new Date(1574704661163L), "624b3117-3ff8-47fb-8b31-8a1673e0a55b", "01545ad0-67d5-4777-bb39-5a79af09624d", new Date(1574704662978L)); CertificateIssuerConfig certificateissuerconfig2 = new CertificateIssuerConfig("a5b43081-d1ee-4bca-94c7-2a74f48169d1", new Date(1574704661163L), "624b3117-3ff8-47fb-8b31-8a1673e0a55b", "01545ad0-67d5-4777-bb39-5a79af09624d", new Date(1574704662978L)); assertNotNull(certificateissuerconfig1); assertNotNull(certificateissuerconfig2); assertNotSame(certificateissuerconfig2, certificateissuerconfig1); assertEquals(certificateissuerconfig2, certificateissuerconfig1); assertEquals(certificateissuerconfig2.hashCode(), certificateissuerconfig1.hashCode()); int hashCode = certificateissuerconfig1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, certificateissuerconfig1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: CertificateIssuerConfig implements SdkModel { @Override public boolean isValid() { return isCertificateIssuerIdValid() && isReferenceValid(); } @Internal CertificateIssuerConfig(String certificateIssuerId, Date createdAt, String id, String reference, Date updatedAt); @Internal CertificateIssuerConfig(CertificateIssuerConfig certificateIssuerConfig); CertificateIssuerConfig(); CertificateIssuerConfig(String id); @Internal CertificateIssuerConfig(Date createdAt, Date updatedAt); CertificateIssuerConfig(String certificateIssuerId, String reference); String getCertificateIssuerId(); @Required void setCertificateIssuerId(String certificateIssuerId); @SuppressWarnings("PMD.UselessParentheses") boolean isCertificateIssuerIdValid(); Date getCreatedAt(); @Override String getId(); @Override void setId(String id); @Internal void setCertificateIssuerConfigId(String certificateIssuerConfigId); String getReference(); @Required void setReference(String reference); @SuppressWarnings("PMD.UselessParentheses") boolean isReferenceValid(); Date getUpdatedAt(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override CertificateIssuerConfig clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { CertificateIssuerConfig certificateissuerconfig = new CertificateIssuerConfig("f3fa6ede-a0d4-4a4c-977a-f8deb40dbdab", new Date(1574704660298L), "fb3dec18-4eec-4602-b3ec-6a1c14af04a2", "3974be8a-4cf9-4d92-a593-498e5462dc16", new Date(1574704666372L)); assertTrue(certificateissuerconfig.isValid()); CertificateIssuerConfig certificateissuerconfigInvalid = new CertificateIssuerConfig(null, new Date(1574704664728L), "6345011a-d2fd-4e42-a7ef-34d50b7d2d63", null, new Date(1574704660811L)); assertFalse(certificateissuerconfigInvalid.isValid()); }
### Question: VerificationResponse implements SdkModel { @Override public VerificationResponse clone() { return new VerificationResponse(this); } @Internal VerificationResponse(String message, boolean successful); @Internal VerificationResponse(VerificationResponse verificationResponse); VerificationResponse(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); String getMessage(); boolean isSuccessful(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override VerificationResponse clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { VerificationResponse verificationresponse1 = new VerificationResponse("4465074a-b3b8-42ed-91f8-840a03e44330", true); VerificationResponse verificationresponse2 = verificationresponse1.clone(); assertNotNull(verificationresponse1); assertNotNull(verificationresponse2); assertNotSame(verificationresponse2, verificationresponse1); assertEquals(verificationresponse2, verificationresponse1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: VerificationResponse implements SdkModel { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((message == null) ? 0 : message.hashCode()); result = prime * result + Objects.hashCode(Boolean.valueOf(successful)); return result; } @Internal VerificationResponse(String message, boolean successful); @Internal VerificationResponse(VerificationResponse verificationResponse); VerificationResponse(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); String getMessage(); boolean isSuccessful(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override VerificationResponse clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { VerificationResponse verificationresponse1 = new VerificationResponse("f3b1e7c0-d8a1-440f-8b21-435987f1e30e", true); VerificationResponse verificationresponse2 = new VerificationResponse("f3b1e7c0-d8a1-440f-8b21-435987f1e30e", true); assertNotNull(verificationresponse1); assertNotNull(verificationresponse2); assertNotSame(verificationresponse2, verificationresponse1); assertEquals(verificationresponse2, verificationresponse1); assertEquals(verificationresponse2.hashCode(), verificationresponse1.hashCode()); int hashCode = verificationresponse1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, verificationresponse1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: ApiUtils { public static boolean comparePaths(String path1, String path2) { final String normalisedPath1 = normalisePath(path1); final String normalisedPath2 = normalisePath(path2); if (normalisedPath1 == null) { return normalisedPath2 == null; } return normalisedPath1.equals(normalisedPath2); } private ApiUtils(); static void checkNotNull(SdkLogger logger, Object arg, String argName); static void checkModelValidity(SdkLogger logger, SdkModel model, String argName); static boolean isCloudException(Throwable exception); static boolean isNotImplementedException(Throwable exception); static boolean isParameterErrorException(Throwable exception); static String normalisePath(String path); static String normaliseResourcePath(String resourcePath); static boolean comparePaths(String path1, String path2); static String toUtcTimestamp(Date date); static Date convertStringToDate(String valueStr); static String convertCamelToSnake(String stringToConvert); static String convertSnakeToCamel(String stringToConvert, boolean capitalAtStart); static URLConnection openConnection(@NonNull URL url, @Nullable ApiClientWrapper client, @NonNull SdkLogger logger); }### Answer: @Test public final void testComparePaths() { assertTrue(ApiUtils.comparePaths(null, null)); assertFalse(ApiUtils.comparePaths(null, "")); assertFalse(ApiUtils.comparePaths("", null)); assertTrue(ApiUtils.comparePaths("/test/1", "test/1")); assertTrue(ApiUtils.comparePaths("test/2", "/test/2")); }
### Question: TranslationUtils { public static DateTime toDateTime(Date date) { return moveToUtc(date); } private TranslationUtils(); static Date toDate(DateTime date); static Date toDate(LocalDate ldate); static Date toDate(Calendar date); static Date toDate(Number timestamp); static Date toDate(Number timestamp, TimeUnit unit); static DateTime toDateTime(Date date); static LocalDate toLocalDate(Date date); static DataFile toDataFile(File file); static DataFile toDataFile(String filePath); static long toLong(Number longE); static long toLong(Date value); static long toLong(String value); static long toLong(Number longE, long defaultValue); static long toLong(Date value, long defaultValue); static long toLong(String stringContainingANumber, long defaultValue); static int toInt(Number number); static int toInt(String value); static int toInt(Number integer, int defaultV); static int toInt(String value, int defaultV); static Integer toInteger(String value, Integer defaultV); static boolean toBool(Boolean bool); static boolean toBool(String value); static boolean toBool(Boolean bool, boolean defaultB); static boolean toBool(String value, boolean defaultV); static double toDouble(Number value); static double toDouble(String value); static double toDouble(Number value, double defaultD); static double toDouble(String value, double defaultD); static URL toUrl(String url); static String toString(Object obj); static Base64 toBase64(Object obj); static byte[] toByteArray(Object obj); static synchronized Date convertTimestamp(String timestamp); static synchronized Date convertTimestamp(String timestamp, Date defaultDate); static synchronized Date convertTimestamp(String timestamp, DateFormat format, Date defaultDate); static synchronized Date convertTimestamp(String timestamp, DateFormat format); static synchronized Date convertRfc3339Timestamp(String timestamp); static synchronized Date convertRfc3339Timestamp(String timestamp, Date defaultDate); static synchronized String toDefaultTimestamp(Date date); static synchronized String toRfc3339Timestamp(Date date); static String toTimestamp(Date date, DateFormat format); static List<String> parseList(String string, String separator); static DateTime moveToUtc(Date date); static Date moveDateTimeToUtc(Date date); static String toUtcTimestamp(Date date); static Date convertStringToDate(String valueStr); static final String METHOD_CONVERT_STRING_TO_DATE; static final String METHOD_CONVERT_OTHER_TO_DATE; static final String METHOD_CONVERT_DATE_TO_DATETIME; static final String METHOD_CONVERT_DATE_TO_LOCALDATE; static final String METHOD_CONVERT_DATE_TO_STRING; static final String METHOD_CONVERT_STRING_TO_URL; static final String METHOD_CONVERT_BOOL_TO_BOOL; static final String METHOD_CONVERT_NUMBER_TO_LONG; static final String METHOD_CONVERT_NUMBER_TO_INT; static final String METHOD_CONVERT_NUMBER_TO_DOUBLE; static final String METHOD_CONVERT_ANY_TO_STRING; static final String METHOD_CONVERT_ANY_TO_BYTE_ARRAY; static final String METHOD_CONVERT_ANY_TO_BASE64; static final String METHOD_CONVERT_TO_DATA_FILE; }### Answer: @Test public void testToDateTime() { DateTime time = new DateTime(1000); assertEquals(time.withZone(DateTimeZone.UTC), TranslationUtils.toDateTime(new Date(1000))); }
### Question: VerificationResponse implements SdkModel { @Override public boolean isValid() { return true; } @Internal VerificationResponse(String message, boolean successful); @Internal VerificationResponse(VerificationResponse verificationResponse); VerificationResponse(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); String getMessage(); boolean isSuccessful(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override VerificationResponse clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { VerificationResponse verificationresponse = new VerificationResponse("74c8d9c1-bb10-4831-866b-a3e3fcf18616", false); assertTrue(verificationresponse.isValid()); }
### Question: VerificationResponse implements SdkModel { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!(obj instanceof VerificationResponse)) { return false; } final VerificationResponse other = (VerificationResponse) obj; if (!other.canEqual(this)) { return false; } if (message == null) { if (other.message != null) { return false; } } else if (!message.equals(other.message)) { return false; } if (successful != other.successful) { return false; } return true; } @Internal VerificationResponse(String message, boolean successful); @Internal VerificationResponse(VerificationResponse verificationResponse); VerificationResponse(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); String getMessage(); boolean isSuccessful(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override VerificationResponse clone(); }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { VerificationResponse verificationresponse1 = new VerificationResponse("451ac9c4-48b0-448d-bcdc-12bf553955ea", true); VerificationResponse verificationresponse2 = new VerificationResponse("451ac9c4-48b0-448d-bcdc-12bf553955ea", true); VerificationResponse verificationresponse3 = new VerificationResponse("046292cb-d96a-4b7d-bab2-4d8d592cfda9", true); assertNotNull(verificationresponse1); assertNotNull(verificationresponse2); assertNotNull(verificationresponse3); assertNotSame(verificationresponse2, verificationresponse1); assertNotSame(verificationresponse3, verificationresponse1); assertEquals(verificationresponse2, verificationresponse1); assertEquals(verificationresponse2, verificationresponse1); assertEquals(verificationresponse1, verificationresponse2); assertEquals(verificationresponse1, verificationresponse1); assertFalse(verificationresponse1.equals(null)); assertNotEquals(verificationresponse3, verificationresponse1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: CertificateIssuer implements SdkModel { @Override public CertificateIssuer clone() { return new CertificateIssuer(this); } @Internal CertificateIssuer(Date createdAt, String description, String id, Map<String, String> issuerAttributes, CertificateIssuerType issuerType, String name); @Internal CertificateIssuer(CertificateIssuer certificateIssuer); CertificateIssuer(); CertificateIssuer(String id); @Internal CertificateIssuer(Date createdAt); CertificateIssuer(CertificateIssuerType issuerType, String name); Date getCreatedAt(); String getDescription(); void setDescription(String description); @SuppressWarnings("PMD.UselessParentheses") boolean isDescriptionValid(); @Override String getId(); @Override void setId(String id); @Internal void setCertificateIssuerId(String certificateIssuerId); Map<String, String> getIssuerAttributes(); void setIssuerAttributes(Map<String, String> issuerAttributes); CertificateIssuerType getIssuerType(); @Required void setIssuerType(CertificateIssuerType issuerType); @Internal @Required void setIssuerType(String issuerType); @SuppressWarnings("PMD.UselessParentheses") boolean isIssuerTypeValid(); String getName(); @Required void setName(String name); @SuppressWarnings("PMD.UselessParentheses") boolean isNameValid(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override CertificateIssuer clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { CertificateIssuer certificateissuer1 = new CertificateIssuer(new Date(1574704669960L), "e6a1c4e6-f6a8-4e66-bb9d-282f45c25ed8", "70dc8f58-f318-40f4-907f-df6c97530557", null, CertificateIssuerType.getDefault(), "0e21b079-93d2-4091-8f3a-19d10ccaf9e1"); CertificateIssuer certificateissuer2 = certificateissuer1.clone(); assertNotNull(certificateissuer1); assertNotNull(certificateissuer2); assertNotSame(certificateissuer2, certificateissuer1); assertEquals(certificateissuer2, certificateissuer1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: CertificateIssuer implements SdkModel { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((createdAt == null) ? 0 : createdAt.hashCode()); result = prime * result + ((description == null) ? 0 : description.hashCode()); result = prime * result + ((id == null) ? 0 : id.hashCode()); result = prime * result + ((issuerAttributes == null) ? 0 : issuerAttributes.hashCode()); result = prime * result + ((issuerType == null) ? 0 : issuerType.hashCode()); result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Internal CertificateIssuer(Date createdAt, String description, String id, Map<String, String> issuerAttributes, CertificateIssuerType issuerType, String name); @Internal CertificateIssuer(CertificateIssuer certificateIssuer); CertificateIssuer(); CertificateIssuer(String id); @Internal CertificateIssuer(Date createdAt); CertificateIssuer(CertificateIssuerType issuerType, String name); Date getCreatedAt(); String getDescription(); void setDescription(String description); @SuppressWarnings("PMD.UselessParentheses") boolean isDescriptionValid(); @Override String getId(); @Override void setId(String id); @Internal void setCertificateIssuerId(String certificateIssuerId); Map<String, String> getIssuerAttributes(); void setIssuerAttributes(Map<String, String> issuerAttributes); CertificateIssuerType getIssuerType(); @Required void setIssuerType(CertificateIssuerType issuerType); @Internal @Required void setIssuerType(String issuerType); @SuppressWarnings("PMD.UselessParentheses") boolean isIssuerTypeValid(); String getName(); @Required void setName(String name); @SuppressWarnings("PMD.UselessParentheses") boolean isNameValid(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override CertificateIssuer clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { CertificateIssuer certificateissuer1 = new CertificateIssuer(new Date(1574704664513L), "f36bdc2e-29c5-464d-98ce-d6dab110dc86", "ca63b0a4-7ad0-4b5c-b768-585c7a3a1dfc", null, CertificateIssuerType.getDefault(), "e48f6211-965c-4f32-bad1-f1be284c844a"); CertificateIssuer certificateissuer2 = new CertificateIssuer(new Date(1574704664513L), "f36bdc2e-29c5-464d-98ce-d6dab110dc86", "ca63b0a4-7ad0-4b5c-b768-585c7a3a1dfc", null, CertificateIssuerType.getDefault(), "e48f6211-965c-4f32-bad1-f1be284c844a"); assertNotNull(certificateissuer1); assertNotNull(certificateissuer2); assertNotSame(certificateissuer2, certificateissuer1); assertEquals(certificateissuer2, certificateissuer1); assertEquals(certificateissuer2.hashCode(), certificateissuer1.hashCode()); int hashCode = certificateissuer1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, certificateissuer1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: CertificateIssuer implements SdkModel { @Override public boolean isValid() { return isDescriptionValid() && isIssuerTypeValid() && isNameValid(); } @Internal CertificateIssuer(Date createdAt, String description, String id, Map<String, String> issuerAttributes, CertificateIssuerType issuerType, String name); @Internal CertificateIssuer(CertificateIssuer certificateIssuer); CertificateIssuer(); CertificateIssuer(String id); @Internal CertificateIssuer(Date createdAt); CertificateIssuer(CertificateIssuerType issuerType, String name); Date getCreatedAt(); String getDescription(); void setDescription(String description); @SuppressWarnings("PMD.UselessParentheses") boolean isDescriptionValid(); @Override String getId(); @Override void setId(String id); @Internal void setCertificateIssuerId(String certificateIssuerId); Map<String, String> getIssuerAttributes(); void setIssuerAttributes(Map<String, String> issuerAttributes); CertificateIssuerType getIssuerType(); @Required void setIssuerType(CertificateIssuerType issuerType); @Internal @Required void setIssuerType(String issuerType); @SuppressWarnings("PMD.UselessParentheses") boolean isIssuerTypeValid(); String getName(); @Required void setName(String name); @SuppressWarnings("PMD.UselessParentheses") boolean isNameValid(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override CertificateIssuer clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { CertificateIssuer certificateissuer = new CertificateIssuer(new Date(1574704665638L), "5a9257f4-d885-4aae-ad0b-20c85898b425", "a2235798-3af3-47f4-9b64-dcf2228237a3", null, CertificateIssuerType.getDefault(), "21df594b-4113-4063-82ce-839973c797e7"); assertTrue(certificateissuer.isValid()); CertificateIssuer certificateissuerInvalid = new CertificateIssuer(new Date(1574704667006L), "061be51e-83a8-4fd2-ab22-1aeaa8c233f000dcf0ac-8364-4fd7-9e2d-e8f0febe70f906a6d146-b93e-45a5-856e-d7685326104d", "53d0a258-cfd3-41e6-b7d5-ed3fc2406dfa", null, null, null); assertFalse(certificateissuerInvalid.isValid()); }
### Question: TrustedCertificate extends AbstractTrustedCertificate { @Override public TrustedCertificate clone() { return new TrustedCertificate(this); } @Internal @SuppressWarnings("PMD.CyclomaticComplexity") TrustedCertificate(String accountId, String certificate, String certificateFingerprint, Date createdAt, String description, int deviceExecutionMode, boolean enrollmentMode, String id, String issuer, String name, String ownerId, TrustedCertificateService service, TrustedCertificateStatus status, String subject, Date updatedAt, boolean valid, Date validity); @Internal TrustedCertificate(TrustedCertificate trustedCertificate); TrustedCertificate(); TrustedCertificate(String id); @Internal @SuppressWarnings({ "PMD.UnusedFormalParameter", "PMD.CyclomaticComplexity" }) TrustedCertificate(String accountId, String certificateFingerprint, Date createdAt, int deviceExecutionMode, boolean isDeveloperCertificate, String issuer, String ownerId, String subject, Date updatedAt, boolean valid, Date validity); TrustedCertificate(String certificate, String name, TrustedCertificateService service); boolean isDeveloperCertificate(); @SuppressWarnings("PMD.BooleanGetMethodName") @Internal boolean getIsDeveloperCertificate(); @SuppressWarnings("PMD.UselessOverridingMethod") @Override boolean isValid(); @Override String toString(); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean equals(Object obj); @Override TrustedCertificate clone(); }### Answer: @Test public void testClone() { try { TrustedCertificate trustedcertificate1 = new TrustedCertificate("2d354731-f898-4d7a-8a0a-1d26b0bc6fdd", "18dc01f9-b6ba-4213-8633-ae1ee99e9a27", "a6210c02-cefc-4853-9de6-2f8022106ca4", new Date(1547147143593L), "6fff6930-2e94-47c1-a302-7a0b96e9c9a8", 76, false, "cc946d3d-6765-448e-9056-733f89eb05b1", "c552bc76-f800-4792-99e9-30b993c70380", "87a845a1-dff8-457e-85b8-b5e8fa8805fd", "92926ebf-19ed-41ba-b122-f6a3801516ec", TrustedCertificateService.getDefault(), TrustedCertificateStatus.getDefault(), "12581bb9-fb72-4e2d-b771-706e22dfd665", new Date(1547147144666L), false, new Date(1547147140890L)); TrustedCertificate trustedcertificate2 = trustedcertificate1.clone(); assertNotNull(trustedcertificate1); assertNotNull(trustedcertificate2); assertNotSame(trustedcertificate2, trustedcertificate1); assertEquals(trustedcertificate2, trustedcertificate1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: ServerCredentials implements SdkModel { @Override public ServerCredentials clone() { return new ServerCredentials(this); } @Internal ServerCredentials(Date createdAt, String id, String serverCertificate, String serverUri); @Internal ServerCredentials(ServerCredentials serverCredentials); ServerCredentials(); ServerCredentials(String id); @Internal ServerCredentials(Date createdAt, String serverCertificate, String serverUri); Date getCreatedAt(); @Override String getId(); @Override void setId(String id); @Internal void setServerCredentialsId(String serverCredentialsId); String getServerCertificate(); String getServerUri(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override ServerCredentials clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { ServerCredentials servercredentials1 = new ServerCredentials(new Date(1574704668706L), "d8400468-4458-4650-937e-3a37a9d71ad7", "ba83423b-405f-4dbf-9f4d-368da1d204e4", "b1eb4991-2051-4e59-b5eb-aa22f32b3028"); ServerCredentials servercredentials2 = servercredentials1.clone(); assertNotNull(servercredentials1); assertNotNull(servercredentials2); assertNotSame(servercredentials2, servercredentials1); assertEquals(servercredentials2, servercredentials1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: ServerCredentials implements SdkModel { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((createdAt == null) ? 0 : createdAt.hashCode()); result = prime * result + ((id == null) ? 0 : id.hashCode()); result = prime * result + ((serverCertificate == null) ? 0 : serverCertificate.hashCode()); result = prime * result + ((serverUri == null) ? 0 : serverUri.hashCode()); return result; } @Internal ServerCredentials(Date createdAt, String id, String serverCertificate, String serverUri); @Internal ServerCredentials(ServerCredentials serverCredentials); ServerCredentials(); ServerCredentials(String id); @Internal ServerCredentials(Date createdAt, String serverCertificate, String serverUri); Date getCreatedAt(); @Override String getId(); @Override void setId(String id); @Internal void setServerCredentialsId(String serverCredentialsId); String getServerCertificate(); String getServerUri(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override ServerCredentials clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { ServerCredentials servercredentials1 = new ServerCredentials(new Date(1574704662442L), "f6686ef6-7a62-47c3-974e-02b26f5f722c", "3d65355c-f644-425e-af7c-b10dd9c1702c", "f465167a-a1c6-42cd-8c56-028b7fced6be"); ServerCredentials servercredentials2 = new ServerCredentials(new Date(1574704662442L), "f6686ef6-7a62-47c3-974e-02b26f5f722c", "3d65355c-f644-425e-af7c-b10dd9c1702c", "f465167a-a1c6-42cd-8c56-028b7fced6be"); assertNotNull(servercredentials1); assertNotNull(servercredentials2); assertNotSame(servercredentials2, servercredentials1); assertEquals(servercredentials2, servercredentials1); assertEquals(servercredentials2.hashCode(), servercredentials1.hashCode()); int hashCode = servercredentials1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, servercredentials1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: ServerCredentials implements SdkModel { @Override public boolean isValid() { return true; } @Internal ServerCredentials(Date createdAt, String id, String serverCertificate, String serverUri); @Internal ServerCredentials(ServerCredentials serverCredentials); ServerCredentials(); ServerCredentials(String id); @Internal ServerCredentials(Date createdAt, String serverCertificate, String serverUri); Date getCreatedAt(); @Override String getId(); @Override void setId(String id); @Internal void setServerCredentialsId(String serverCredentialsId); String getServerCertificate(); String getServerUri(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override ServerCredentials clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { ServerCredentials servercredentials = new ServerCredentials(new Date(1574704670366L), "4b756791-6471-4e79-afae-2cd72d97e9ca", "5ce9d898-d653-4d89-8c03-630d825186b4", "f5d7a875-8d2e-4ea6-845c-3731f091bbe8"); assertTrue(servercredentials.isValid()); }
### Question: ServerCredentials implements SdkModel { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!(obj instanceof ServerCredentials)) { return false; } final ServerCredentials other = (ServerCredentials) obj; if (!other.canEqual(this)) { return false; } if (createdAt == null) { if (other.createdAt != null) { return false; } } else if (!createdAt.equals(other.createdAt)) { return false; } if (id == null) { if (other.id != null) { return false; } } else if (!id.equals(other.id)) { return false; } if (serverCertificate == null) { if (other.serverCertificate != null) { return false; } } else if (!serverCertificate.equals(other.serverCertificate)) { return false; } if (serverUri == null) { if (other.serverUri != null) { return false; } } else if (!serverUri.equals(other.serverUri)) { return false; } return true; } @Internal ServerCredentials(Date createdAt, String id, String serverCertificate, String serverUri); @Internal ServerCredentials(ServerCredentials serverCredentials); ServerCredentials(); ServerCredentials(String id); @Internal ServerCredentials(Date createdAt, String serverCertificate, String serverUri); Date getCreatedAt(); @Override String getId(); @Override void setId(String id); @Internal void setServerCredentialsId(String serverCredentialsId); String getServerCertificate(); String getServerUri(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override ServerCredentials clone(); }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { ServerCredentials servercredentials1 = new ServerCredentials(new Date(1574704665250L), "b116795d-9a9a-43d3-b51b-1b4447de6aea", "e8e85163-8320-4bc5-864e-21c5d87d3ebe", "ec07982a-3ea0-49f8-8a56-f24468accf48"); ServerCredentials servercredentials2 = new ServerCredentials(new Date(1574704665250L), "b116795d-9a9a-43d3-b51b-1b4447de6aea", "e8e85163-8320-4bc5-864e-21c5d87d3ebe", "ec07982a-3ea0-49f8-8a56-f24468accf48"); ServerCredentials servercredentials3 = new ServerCredentials(new Date(1574704667741L), "4359fad0-c68b-4eae-a2d5-ed3d98d936b9", "fa5379e8-200d-45ac-9055-95e178551fef", "a5cb74b9-63f5-4f51-a6de-dd9ab9086ec0"); assertNotNull(servercredentials1); assertNotNull(servercredentials2); assertNotNull(servercredentials3); assertNotSame(servercredentials2, servercredentials1); assertNotSame(servercredentials3, servercredentials1); assertEquals(servercredentials2, servercredentials1); assertEquals(servercredentials2, servercredentials1); assertEquals(servercredentials1, servercredentials2); assertEquals(servercredentials1, servercredentials1); assertFalse(servercredentials1.equals(null)); assertNotEquals(servercredentials3, servercredentials1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DeveloperCertificate implements SdkModel { @Override public DeveloperCertificate clone() { return new DeveloperCertificate(this); } @Internal @SuppressWarnings("PMD.CyclomaticComplexity") DeveloperCertificate(String accountId, String certificate, Date createdAt, String description, String developerPrivateKey, String id, String name, String securityFileContent); @Internal DeveloperCertificate(DeveloperCertificate developerCertificate); DeveloperCertificate(); DeveloperCertificate(String id); @Internal DeveloperCertificate(String accountId, String certificate, Date createdAt, String developerPrivateKey, String securityFileContent); String getAccountId(); String getCertificate(); Date getCreatedAt(); String getDescription(); void setDescription(String description); String getDeveloperPrivateKey(); @Override String getId(); @Override void setId(String id); @Internal void setDeveloperCertificateId(String developerCertificateId); String getName(); @Required void setName(String name); @SuppressWarnings("PMD.UselessParentheses") boolean isNameValid(); String getSecurityFileContent(); @Override String toString(); @Override int hashCode(); @Override @SuppressWarnings({ "PMD.ExcessiveMethodLength", "PMD.NcssMethodCount" }) boolean equals(Object obj); @Override boolean isValid(); @Override DeveloperCertificate clone(); @Internal static final Map<String, String> FILTER_MAPPING; }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { DeveloperCertificate developercertificate1 = new DeveloperCertificate("1251ea85-f5e8-47af-a2bc-3b9e3b0162f3", "81eb4129-5a65-4812-ade8-6446962c190f", new Date(1574704660559L), "435e1eca-4979-4b23-8142-0b64d38ad25f", "cdaceb09-8fe9-4a81-882f-8cc9bcdb7fc3", "009a2f0c-0f6a-40a6-9365-91648d3704ab", "e8f9519b-47be-4a3a-bd88-2b11a97e210d", "307572d9-3ef5-439f-9007-a443c80f4644"); DeveloperCertificate developercertificate2 = developercertificate1.clone(); assertNotNull(developercertificate1); assertNotNull(developercertificate2); assertNotSame(developercertificate2, developercertificate1); assertEquals(developercertificate2, developercertificate1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DeveloperCertificate implements SdkModel { @Override public boolean isValid() { return isNameValid(); } @Internal @SuppressWarnings("PMD.CyclomaticComplexity") DeveloperCertificate(String accountId, String certificate, Date createdAt, String description, String developerPrivateKey, String id, String name, String securityFileContent); @Internal DeveloperCertificate(DeveloperCertificate developerCertificate); DeveloperCertificate(); DeveloperCertificate(String id); @Internal DeveloperCertificate(String accountId, String certificate, Date createdAt, String developerPrivateKey, String securityFileContent); String getAccountId(); String getCertificate(); Date getCreatedAt(); String getDescription(); void setDescription(String description); String getDeveloperPrivateKey(); @Override String getId(); @Override void setId(String id); @Internal void setDeveloperCertificateId(String developerCertificateId); String getName(); @Required void setName(String name); @SuppressWarnings("PMD.UselessParentheses") boolean isNameValid(); String getSecurityFileContent(); @Override String toString(); @Override int hashCode(); @Override @SuppressWarnings({ "PMD.ExcessiveMethodLength", "PMD.NcssMethodCount" }) boolean equals(Object obj); @Override boolean isValid(); @Override DeveloperCertificate clone(); @Internal static final Map<String, String> FILTER_MAPPING; }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { DeveloperCertificate developercertificate = new DeveloperCertificate("33a8d98e-d6db-4e4e-b782-402b9955845a", "cd32905c-af9e-4a94-bb30-987e3551a130", new Date(1574704665962L), "203102f1-98d4-458f-b2ca-43f3fb3d5d9f", "25021e2a-59b8-4497-86d6-f857acfa8672", "9f117ef7-4b52-481d-a2a2-54c706b93598", "2516dfaa-c00d-412b-a728-954d7e9c4866", "1adcbe51-0528-47e7-aa51-90fc9eaca593"); assertTrue(developercertificate.isValid()); DeveloperCertificate developercertificateInvalid = new DeveloperCertificate("1913c388-2e7a-441b-932a-4e33f52f0d04", "cd0ccda2-d47b-447c-817f-4cbddc0f41c8", new Date(1574704665819L), "d369f4fc-6295-4dd9-b9a1-53c91cf448de", "93acb39b-b56e-4991-b8ba-45cd65fda56d", "bb23fb0c-e0e7-4f85-b0a2-75569a3ceed3", null, "8ae4ada8-d3b6-4d3a-bfee-1d0358296965"); assertFalse(developercertificateInvalid.isValid()); }
### Question: CertificateEnrollment implements SdkModel { @Override public CertificateEnrollment clone() { return new CertificateEnrollment(this); } @Internal @SuppressWarnings("PMD.CyclomaticComplexity") CertificateEnrollment(String certificateName, Date createdAt, String deviceId, CertificateEnrollmentEnrollResult enrollResult, String enrollResultDetail, CertificateEnrollmentEnrollStatus enrollStatus, String id, Date updatedAt); @Internal CertificateEnrollment(CertificateEnrollment certificateEnrollment); CertificateEnrollment(); CertificateEnrollment(String id); @Internal CertificateEnrollment(String certificateName, Date createdAt, String deviceId, CertificateEnrollmentEnrollResult enrollResult, String enrollResultDetail, CertificateEnrollmentEnrollStatus enrollStatus, Date updatedAt); String getCertificateName(); Date getCreatedAt(); String getDeviceId(); CertificateEnrollmentEnrollResult getEnrollResult(); String getEnrollResultDetail(); CertificateEnrollmentEnrollStatus getEnrollStatus(); @Override String getId(); @Override void setId(String id); @Internal void setCertificateEnrollmentId(String certificateEnrollmentId); Date getUpdatedAt(); @Override String toString(); @Override int hashCode(); @Override @SuppressWarnings({ "PMD.ExcessiveMethodLength", "PMD.NcssMethodCount" }) boolean equals(Object obj); @Override boolean isValid(); @Override CertificateEnrollment clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { CertificateEnrollment certificateenrollment1 = new CertificateEnrollment("_-].v", new Date(1574704666141L), "666792aa-8dd0-463c-b892-0dfcbfb16717", CertificateEnrollmentEnrollResult.getDefault(), "e5f3f017-2c2e-4bb7-9a91-6a96f1ad8b91", CertificateEnrollmentEnrollStatus.getDefault(), "781f0cce-fd58-4031-8cfb-097d9f330f9e", new Date(1574704668242L)); CertificateEnrollment certificateenrollment2 = certificateenrollment1.clone(); assertNotNull(certificateenrollment1); assertNotNull(certificateenrollment2); assertNotSame(certificateenrollment2, certificateenrollment1); assertEquals(certificateenrollment2, certificateenrollment1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: CertificateEnrollment implements SdkModel { @Override public boolean isValid() { return true; } @Internal @SuppressWarnings("PMD.CyclomaticComplexity") CertificateEnrollment(String certificateName, Date createdAt, String deviceId, CertificateEnrollmentEnrollResult enrollResult, String enrollResultDetail, CertificateEnrollmentEnrollStatus enrollStatus, String id, Date updatedAt); @Internal CertificateEnrollment(CertificateEnrollment certificateEnrollment); CertificateEnrollment(); CertificateEnrollment(String id); @Internal CertificateEnrollment(String certificateName, Date createdAt, String deviceId, CertificateEnrollmentEnrollResult enrollResult, String enrollResultDetail, CertificateEnrollmentEnrollStatus enrollStatus, Date updatedAt); String getCertificateName(); Date getCreatedAt(); String getDeviceId(); CertificateEnrollmentEnrollResult getEnrollResult(); String getEnrollResultDetail(); CertificateEnrollmentEnrollStatus getEnrollStatus(); @Override String getId(); @Override void setId(String id); @Internal void setCertificateEnrollmentId(String certificateEnrollmentId); Date getUpdatedAt(); @Override String toString(); @Override int hashCode(); @Override @SuppressWarnings({ "PMD.ExcessiveMethodLength", "PMD.NcssMethodCount" }) boolean equals(Object obj); @Override boolean isValid(); @Override CertificateEnrollment clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { CertificateEnrollment certificateenrollment = new CertificateEnrollment("_-].v", new Date(1574704668222L), "802ca3cd-cfa2-488a-b2f5-9365fd5179fb", CertificateEnrollmentEnrollResult.getDefault(), "cc020876-dc92-4e16-9368-fc9e2cd183a7", CertificateEnrollmentEnrollStatus.getDefault(), "991ec6bc-032f-470d-b7f9-a2fcad660325", new Date(1574704669046L)); assertTrue(certificateenrollment.isValid()); }
### Question: SubtenantTrustedCertificate extends AbstractSubtenantTrustedCertificate { @Override public SubtenantTrustedCertificate clone() { return new SubtenantTrustedCertificate(this); } @Internal @SuppressWarnings("PMD.CyclomaticComplexity") SubtenantTrustedCertificate(String accountId, String certificate, String certificateFingerprint, Date createdAt, String description, int deviceExecutionMode, boolean enrollmentMode, String id, String issuer, String name, String ownerId, SubtenantTrustedCertificateService service, SubtenantTrustedCertificateStatus status, String subject, Date updatedAt, boolean valid, Date validity); @Internal SubtenantTrustedCertificate(SubtenantTrustedCertificate subtenantTrustedCertificate); SubtenantTrustedCertificate(); SubtenantTrustedCertificate(String id); @SuppressWarnings("PMD.UnusedFormalParameter") @Internal SubtenantTrustedCertificate(String certificateFingerprint, Date createdAt, int deviceExecutionMode, boolean isDeveloperCertificate, String issuer, String ownerId, String subject, Date updatedAt, boolean valid, Date validity); SubtenantTrustedCertificate(String accountId, String certificate, String name, SubtenantTrustedCertificateService service); boolean isDeveloperCertificate(); @SuppressWarnings("PMD.BooleanGetMethodName") @Internal boolean getIsDeveloperCertificate(); @SuppressWarnings("PMD.UselessOverridingMethod") @Override boolean isValid(); @Override String toString(); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean equals(Object obj); @Override SubtenantTrustedCertificate clone(); }### Answer: @Test public void testClone() { try { SubtenantTrustedCertificate subtenanttrustedcertificate1 = new SubtenantTrustedCertificate("2c2c63da-d7f8-408d-9186-565700938047", "2b7cc35c-052a-479d-b351-519efd55e0dc", "13602a42-ea4d-49e0-a5bd-aa65384f289c", new Date(1547147139208L), "c9b4e88d-f453-4c45-8c6a-b60165873bc2", -52, false, "759cee00-d8ca-4b2e-bfa0-d1359938a090", "5d99e689-3b56-44a4-8777-f400cea48d8d", "69cf4d41-57a8-4f37-bbd2-1cfd188dd964", "95d93b68-f60f-493f-9c19-19c20b2034d4", SubtenantTrustedCertificateService.getDefault(), SubtenantTrustedCertificateStatus.getDefault(), "b703accb-a23e-43d6-b179-540308f85357", new Date(1547147134537L), true, new Date(1547147135770L)); SubtenantTrustedCertificate subtenanttrustedcertificate2 = subtenanttrustedcertificate1.clone(); assertNotNull(subtenanttrustedcertificate1); assertNotNull(subtenanttrustedcertificate2); assertNotSame(subtenanttrustedcertificate2, subtenanttrustedcertificate1); assertEquals(subtenanttrustedcertificate2, subtenanttrustedcertificate1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: LightThemeImage extends AbstractLightThemeImage { @Override public LightThemeImage clone() { return new LightThemeImage(this); } @Internal LightThemeImage(LightThemeImageReference reference, String staticUri, Date updatedAt); @Internal LightThemeImage(LightThemeImage lightThemeImage); LightThemeImage(); @Internal LightThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setLightThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override LightThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { LightThemeImage lightthemeimage1 = new LightThemeImage(LightThemeImageReference.getDefault(), "54674b94-0b92-48b3-8309-953bef5ebf17", new Date(1559758606105L)); LightThemeImage lightthemeimage2 = lightthemeimage1.clone(); assertNotNull(lightthemeimage1); assertNotNull(lightthemeimage2); assertNotSame(lightthemeimage2, lightthemeimage1); assertEquals(lightthemeimage2, lightthemeimage1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: LightThemeImage extends AbstractLightThemeImage { @SuppressWarnings("PMD.UselessOverridingMethod") @Override public int hashCode() { return super.hashCode(); } @Internal LightThemeImage(LightThemeImageReference reference, String staticUri, Date updatedAt); @Internal LightThemeImage(LightThemeImage lightThemeImage); LightThemeImage(); @Internal LightThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setLightThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override LightThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { LightThemeImage lightthemeimage1 = new LightThemeImage(LightThemeImageReference.getDefault(), "ca84ace3-ffeb-4176-acf0-1af1a1bda75e", new Date(1559758610336L)); LightThemeImage lightthemeimage2 = new LightThemeImage(LightThemeImageReference.getDefault(), "ca84ace3-ffeb-4176-acf0-1af1a1bda75e", new Date(1559758610336L)); assertNotNull(lightthemeimage1); assertNotNull(lightthemeimage2); assertNotSame(lightthemeimage2, lightthemeimage1); assertEquals(lightthemeimage2, lightthemeimage1); assertEquals(lightthemeimage2.hashCode(), lightthemeimage1.hashCode()); int hashCode = lightthemeimage1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, lightthemeimage1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: LightThemeImage extends AbstractLightThemeImage { @Override public boolean isValid() { return super.isValid() && reference != null; } @Internal LightThemeImage(LightThemeImageReference reference, String staticUri, Date updatedAt); @Internal LightThemeImage(LightThemeImage lightThemeImage); LightThemeImage(); @Internal LightThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setLightThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override LightThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { LightThemeImage lightthemeimage = new LightThemeImage(LightThemeImageReference.getDefault(), "c5482898-d420-4e85-a50c-7d66ef82cc51", new Date(1559758605229L)); assertTrue(lightthemeimage.isValid()); LightThemeImage lightthemeimageInvalid = new LightThemeImage(null, "26290c7e-04a0-4237-9068-5ebeb567661b", new Date(1559758609337L)); assertFalse(lightthemeimageInvalid.isValid()); }
### Question: LightThemeImage extends AbstractLightThemeImage { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!super.equals(obj)) { return false; } if (!(obj instanceof LightThemeImage)) { return false; } final LightThemeImage other = (LightThemeImage) obj; if (!other.canEqual(this)) { return false; } return true; } @Internal LightThemeImage(LightThemeImageReference reference, String staticUri, Date updatedAt); @Internal LightThemeImage(LightThemeImage lightThemeImage); LightThemeImage(); @Internal LightThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setLightThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override LightThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { LightThemeImage lightthemeimage1 = new LightThemeImage(LightThemeImageReference.getDefault(), "5d6880ee-7b55-4e0f-b68d-8de258d55ec4", new Date(1559758612037L)); LightThemeImage lightthemeimage2 = new LightThemeImage(LightThemeImageReference.getDefault(), "5d6880ee-7b55-4e0f-b68d-8de258d55ec4", new Date(1559758612037L)); LightThemeImage lightthemeimage3 = new LightThemeImage(LightThemeImageReference.getDefault(), "ca0ed660-72d6-48c7-ae17-0b8bc179fb35", new Date(1559758611017L)); assertNotNull(lightthemeimage1); assertNotNull(lightthemeimage2); assertNotNull(lightthemeimage3); assertNotSame(lightthemeimage2, lightthemeimage1); assertNotSame(lightthemeimage3, lightthemeimage1); assertEquals(lightthemeimage2, lightthemeimage1); assertEquals(lightthemeimage2, lightthemeimage1); assertEquals(lightthemeimage1, lightthemeimage2); assertEquals(lightthemeimage1, lightthemeimage1); assertFalse(lightthemeimage1.equals(null)); assertNotEquals(lightthemeimage3, lightthemeimage1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: FileDownload { public void download(String content) throws MbedCloudException { checkParameters(); if (content == null) { throw new MbedCloudException("The file to download is empty"); } if (logger != null) { logger.logInfo("Downloading data to [" + destination.getName() + "]"); } try (PrintWriter out = new PrintWriter(destination, StandardCharsets.UTF_8.name())) { out.println(content); } catch (IOException exception) { throw new MbedCloudException("The file could not be downloaded", exception); } downloaded = true; } FileDownload(URL source, File destination); FileDownload(URL source); FileDownload(String sourceUrl, String filePath, String fileName); FileDownload(String sourceUrl, String destinationPath); FileDownload(File destination); FileDownload(String destinationPath); FileDownload(Extension extension); FileDownload(); URL getSource(); File getDestination(); DataFile getDestinationFile(); boolean isDownloaded(); void setDownloaded(boolean downloaded); void setLogger(SdkLogger logger); ApiClientWrapper getClient(); void setClient(ApiClientWrapper client); void download(String content); void download(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testDownload() { final String fileUrl = "http: try { URL url = new URL(fileUrl); ApiClientWrapper client = new ApiClientWrapper(ConnectionOptions.newConfiguration("temp", url.getProtocol() + ": + url.getHost())); FileDownload download = new FileDownload(url); download.setClient(client); assertFalse(download.isDownloaded()); download.download(); DataFile dest1 = download.getDestinationFile(); assertTrue(download.isDownloaded()); DataFile dest2 = download.getDestinationFile(); assertNotNull(dest1); assertTrue(dest1.isValid()); dest1.getFile().deleteOnExit(); assertEquals(dest1, dest2); assertTrue(dest1.exists()); assertEquals("3aa55f03c298b83cd7708e90d289afbd", dest1.getMd5Checksum()); assertNotNull(dest1.getFileName()); assertTrue(dest1.getFileName().contains("10MB")); assertEquals(DataFile.BINARY_FILE_MEDIA_TYPE, dest1.getContentType()); client.close(); } catch (MalformedURLException \| MbedCloudException exception) { exception.printStackTrace(); fail(exception.getMessage()); } }
### Question: SubtenantDarkThemeImage extends AbstractSubtenantDarkThemeImage { @Override public SubtenantDarkThemeImage clone() { return new SubtenantDarkThemeImage(this); } @Internal SubtenantDarkThemeImage(SubtenantDarkThemeImageReference reference, String staticUri, Date updatedAt); @Internal SubtenantDarkThemeImage(SubtenantDarkThemeImage subtenantDarkThemeImage); SubtenantDarkThemeImage(); @Internal SubtenantDarkThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setSubtenantDarkThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantDarkThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { SubtenantDarkThemeImage subtenantdarkthemeimage1 = new SubtenantDarkThemeImage(SubtenantDarkThemeImageReference.getDefault(), "4be3bdf9-26b9-4a28-a9d5-dfa142255cf8", new Date(1559758606635L)); SubtenantDarkThemeImage subtenantdarkthemeimage2 = subtenantdarkthemeimage1.clone(); assertNotNull(subtenantdarkthemeimage1); assertNotNull(subtenantdarkthemeimage2); assertNotSame(subtenantdarkthemeimage2, subtenantdarkthemeimage1); assertEquals(subtenantdarkthemeimage2, subtenantdarkthemeimage1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: SubtenantDarkThemeImage extends AbstractSubtenantDarkThemeImage { @SuppressWarnings("PMD.UselessOverridingMethod") @Override public int hashCode() { return super.hashCode(); } @Internal SubtenantDarkThemeImage(SubtenantDarkThemeImageReference reference, String staticUri, Date updatedAt); @Internal SubtenantDarkThemeImage(SubtenantDarkThemeImage subtenantDarkThemeImage); SubtenantDarkThemeImage(); @Internal SubtenantDarkThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setSubtenantDarkThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantDarkThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { SubtenantDarkThemeImage subtenantdarkthemeimage1 = new SubtenantDarkThemeImage(SubtenantDarkThemeImageReference.getDefault(), "dc65f9c2-c28b-445c-91b8-f48511c986cf", new Date(1559758611092L)); SubtenantDarkThemeImage subtenantdarkthemeimage2 = new SubtenantDarkThemeImage(SubtenantDarkThemeImageReference.getDefault(), "dc65f9c2-c28b-445c-91b8-f48511c986cf", new Date(1559758611092L)); assertNotNull(subtenantdarkthemeimage1); assertNotNull(subtenantdarkthemeimage2); assertNotSame(subtenantdarkthemeimage2, subtenantdarkthemeimage1); assertEquals(subtenantdarkthemeimage2, subtenantdarkthemeimage1); assertEquals(subtenantdarkthemeimage2.hashCode(), subtenantdarkthemeimage1.hashCode()); int hashCode = subtenantdarkthemeimage1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, subtenantdarkthemeimage1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: SubtenantDarkThemeImage extends AbstractSubtenantDarkThemeImage { @Override public boolean isValid() { return super.isValid() && reference != null; } @Internal SubtenantDarkThemeImage(SubtenantDarkThemeImageReference reference, String staticUri, Date updatedAt); @Internal SubtenantDarkThemeImage(SubtenantDarkThemeImage subtenantDarkThemeImage); SubtenantDarkThemeImage(); @Internal SubtenantDarkThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setSubtenantDarkThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantDarkThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { SubtenantDarkThemeImage subtenantdarkthemeimage = new SubtenantDarkThemeImage(SubtenantDarkThemeImageReference.getDefault(), "94079e53-16ea-4fd8-99cd-20def25f6bd9", new Date(1559758607480L)); assertTrue(subtenantdarkthemeimage.isValid()); SubtenantDarkThemeImage subtenantdarkthemeimageInvalid = new SubtenantDarkThemeImage(null, "e4367d52-f1a9-43ad-9107-62a0db00b1b1", new Date(1559758605104L)); assertFalse(subtenantdarkthemeimageInvalid.isValid()); }
### Question: SubtenantDarkThemeImage extends AbstractSubtenantDarkThemeImage { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!super.equals(obj)) { return false; } if (!(obj instanceof SubtenantDarkThemeImage)) { return false; } final SubtenantDarkThemeImage other = (SubtenantDarkThemeImage) obj; if (!other.canEqual(this)) { return false; } return true; } @Internal SubtenantDarkThemeImage(SubtenantDarkThemeImageReference reference, String staticUri, Date updatedAt); @Internal SubtenantDarkThemeImage(SubtenantDarkThemeImage subtenantDarkThemeImage); SubtenantDarkThemeImage(); @Internal SubtenantDarkThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setSubtenantDarkThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantDarkThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { SubtenantDarkThemeImage subtenantdarkthemeimage1 = new SubtenantDarkThemeImage(SubtenantDarkThemeImageReference.getDefault(), "4dde91ca-1507-4b72-88b3-3df29c865fa3", new Date(1559758606322L)); SubtenantDarkThemeImage subtenantdarkthemeimage2 = new SubtenantDarkThemeImage(SubtenantDarkThemeImageReference.getDefault(), "4dde91ca-1507-4b72-88b3-3df29c865fa3", new Date(1559758606322L)); SubtenantDarkThemeImage subtenantdarkthemeimage3 = new SubtenantDarkThemeImage(SubtenantDarkThemeImageReference.getDefault(), "15589769-b1d4-4a6e-9e36-d69b6f2f94af", new Date(1559758607935L)); assertNotNull(subtenantdarkthemeimage1); assertNotNull(subtenantdarkthemeimage2); assertNotNull(subtenantdarkthemeimage3); assertNotSame(subtenantdarkthemeimage2, subtenantdarkthemeimage1); assertNotSame(subtenantdarkthemeimage3, subtenantdarkthemeimage1); assertEquals(subtenantdarkthemeimage2, subtenantdarkthemeimage1); assertEquals(subtenantdarkthemeimage2, subtenantdarkthemeimage1); assertEquals(subtenantdarkthemeimage1, subtenantdarkthemeimage2); assertEquals(subtenantdarkthemeimage1, subtenantdarkthemeimage1); assertFalse(subtenantdarkthemeimage1.equals(null)); assertNotEquals(subtenantdarkthemeimage3, subtenantdarkthemeimage1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: SubtenantLightThemeImage extends AbstractSubtenantLightThemeImage { @Override public SubtenantLightThemeImage clone() { return new SubtenantLightThemeImage(this); } @Internal SubtenantLightThemeImage(SubtenantLightThemeImageReference reference, String staticUri, Date updatedAt); @Internal SubtenantLightThemeImage(SubtenantLightThemeImage subtenantLightThemeImage); SubtenantLightThemeImage(); @Internal SubtenantLightThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setSubtenantLightThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantLightThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { SubtenantLightThemeImage subtenantlightthemeimage1 = new SubtenantLightThemeImage(SubtenantLightThemeImageReference.getDefault(), "42a52f07-6a98-4915-bbf5-7de708f371e3", new Date(1559758605443L)); SubtenantLightThemeImage subtenantlightthemeimage2 = subtenantlightthemeimage1.clone(); assertNotNull(subtenantlightthemeimage1); assertNotNull(subtenantlightthemeimage2); assertNotSame(subtenantlightthemeimage2, subtenantlightthemeimage1); assertEquals(subtenantlightthemeimage2, subtenantlightthemeimage1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: SubtenantLightThemeImage extends AbstractSubtenantLightThemeImage { @SuppressWarnings("PMD.UselessOverridingMethod") @Override public int hashCode() { return super.hashCode(); } @Internal SubtenantLightThemeImage(SubtenantLightThemeImageReference reference, String staticUri, Date updatedAt); @Internal SubtenantLightThemeImage(SubtenantLightThemeImage subtenantLightThemeImage); SubtenantLightThemeImage(); @Internal SubtenantLightThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setSubtenantLightThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantLightThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { SubtenantLightThemeImage subtenantlightthemeimage1 = new SubtenantLightThemeImage(SubtenantLightThemeImageReference.getDefault(), "9fc2b335-e68a-401c-8150-9a441921fdd5", new Date(1559758609790L)); SubtenantLightThemeImage subtenantlightthemeimage2 = new SubtenantLightThemeImage(SubtenantLightThemeImageReference.getDefault(), "9fc2b335-e68a-401c-8150-9a441921fdd5", new Date(1559758609790L)); assertNotNull(subtenantlightthemeimage1); assertNotNull(subtenantlightthemeimage2); assertNotSame(subtenantlightthemeimage2, subtenantlightthemeimage1); assertEquals(subtenantlightthemeimage2, subtenantlightthemeimage1); assertEquals(subtenantlightthemeimage2.hashCode(), subtenantlightthemeimage1.hashCode()); int hashCode = subtenantlightthemeimage1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, subtenantlightthemeimage1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: SubtenantLightThemeImage extends AbstractSubtenantLightThemeImage { @Override public boolean isValid() { return super.isValid() && reference != null; } @Internal SubtenantLightThemeImage(SubtenantLightThemeImageReference reference, String staticUri, Date updatedAt); @Internal SubtenantLightThemeImage(SubtenantLightThemeImage subtenantLightThemeImage); SubtenantLightThemeImage(); @Internal SubtenantLightThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setSubtenantLightThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantLightThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { SubtenantLightThemeImage subtenantlightthemeimage = new SubtenantLightThemeImage(SubtenantLightThemeImageReference.getDefault(), "64c88130-1f8a-4221-aea3-dbb4d96adeab", new Date(1559758604019L)); assertTrue(subtenantlightthemeimage.isValid()); SubtenantLightThemeImage subtenantlightthemeimageInvalid = new SubtenantLightThemeImage(null, "66d7cc11-6101-4607-8bbb-a60ff9273fcd", new Date(1559758611154L)); assertFalse(subtenantlightthemeimageInvalid.isValid()); }
### Question: SubtenantLightThemeImage extends AbstractSubtenantLightThemeImage { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!super.equals(obj)) { return false; } if (!(obj instanceof SubtenantLightThemeImage)) { return false; } final SubtenantLightThemeImage other = (SubtenantLightThemeImage) obj; if (!other.canEqual(this)) { return false; } return true; } @Internal SubtenantLightThemeImage(SubtenantLightThemeImageReference reference, String staticUri, Date updatedAt); @Internal SubtenantLightThemeImage(SubtenantLightThemeImage subtenantLightThemeImage); SubtenantLightThemeImage(); @Internal SubtenantLightThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setSubtenantLightThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantLightThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { SubtenantLightThemeImage subtenantlightthemeimage1 = new SubtenantLightThemeImage(SubtenantLightThemeImageReference.getDefault(), "7a99a08d-604b-4276-9358-3c2853334c0f", new Date(1559758603721L)); SubtenantLightThemeImage subtenantlightthemeimage2 = new SubtenantLightThemeImage(SubtenantLightThemeImageReference.getDefault(), "7a99a08d-604b-4276-9358-3c2853334c0f", new Date(1559758603721L)); SubtenantLightThemeImage subtenantlightthemeimage3 = new SubtenantLightThemeImage(SubtenantLightThemeImageReference.getDefault(), "e10ea029-3801-4a9d-8e59-cd30e2790270", new Date(1559758611619L)); assertNotNull(subtenantlightthemeimage1); assertNotNull(subtenantlightthemeimage2); assertNotNull(subtenantlightthemeimage3); assertNotSame(subtenantlightthemeimage2, subtenantlightthemeimage1); assertNotSame(subtenantlightthemeimage3, subtenantlightthemeimage1); assertEquals(subtenantlightthemeimage2, subtenantlightthemeimage1); assertEquals(subtenantlightthemeimage2, subtenantlightthemeimage1); assertEquals(subtenantlightthemeimage1, subtenantlightthemeimage2); assertEquals(subtenantlightthemeimage1, subtenantlightthemeimage1); assertFalse(subtenantlightthemeimage1.equals(null)); assertNotEquals(subtenantlightthemeimage3, subtenantlightthemeimage1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: LightThemeColor extends AbstractLightThemeColor { @Override public LightThemeColor clone() { return new LightThemeColor(this); } @Internal LightThemeColor(String color, LightThemeColorReference reference, Date updatedAt); @Internal LightThemeColor(LightThemeColor lightThemeColor); LightThemeColor(); @Internal LightThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setLightThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override LightThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { LightThemeColor lightthemecolor1 = new LightThemeColor("9cda12d9-5935-4d9b-959a-d2ca5d5da205", LightThemeColorReference.getDefault(), new Date(1559758604463L)); LightThemeColor lightthemecolor2 = lightthemecolor1.clone(); assertNotNull(lightthemecolor1); assertNotNull(lightthemecolor2); assertNotSame(lightthemecolor2, lightthemecolor1); assertEquals(lightthemecolor2, lightthemecolor1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: LightThemeColor extends AbstractLightThemeColor { @SuppressWarnings("PMD.UselessOverridingMethod") @Override public int hashCode() { return super.hashCode(); } @Internal LightThemeColor(String color, LightThemeColorReference reference, Date updatedAt); @Internal LightThemeColor(LightThemeColor lightThemeColor); LightThemeColor(); @Internal LightThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setLightThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override LightThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { LightThemeColor lightthemecolor1 = new LightThemeColor("6f74fcc4-b31f-49c4-9ff7-94ddc7083dfa", LightThemeColorReference.getDefault(), new Date(1559758607239L)); LightThemeColor lightthemecolor2 = new LightThemeColor("6f74fcc4-b31f-49c4-9ff7-94ddc7083dfa", LightThemeColorReference.getDefault(), new Date(1559758607239L)); assertNotNull(lightthemecolor1); assertNotNull(lightthemecolor2); assertNotSame(lightthemecolor2, lightthemecolor1); assertEquals(lightthemecolor2, lightthemecolor1); assertEquals(lightthemecolor2.hashCode(), lightthemecolor1.hashCode()); int hashCode = lightthemecolor1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, lightthemecolor1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: ConnectionOptions implements Cloneable, Serializable { public ConnectionOptions host(String cloudHost) { setHost(cloudHost); return this; } ConnectionOptions(); ConnectionOptions(String apiKey); ConnectionOptions(String apiKey, String host); static ConnectionOptions newConfiguration(); static ConnectionOptions newConfiguration(String apiKey); static ConnectionOptions newConfiguration(String apiKey, String host); String getApiKey(); void setApiKey(String apiKey); boolean isApiKeyEmpty(); boolean isHostEmpty(); boolean isValid(); String getHost(); URL getHostUrl(); void setHost(String host); ConnectionOptions host(String cloudHost); CallLogLevel getClientLogLevel(); void setClientLogLevel(CallLogLevel clientLogLevel); void setClientLogLevel(String clientLogLevel); ConnectionOptions logLevel(CallLogLevel logLevelOfTheHttpClient); TimePeriod getRequestTimeout(); void setRequestTimeout(TimePeriod requestTimeout); boolean hasCustomRequestTimeout(); boolean isAutostartDaemon(); void setAutostartDaemon(@DefaultValue(value = "TRUE") boolean autostartDaemon); ConnectionOptions autostartDaemon(@DefaultValue(value = "TRUE") boolean autostartDaemonMode); ConnectionOptions autostartDaemon(); boolean isForceClear(); void setForceClear(@DefaultValue(value = "FALSE") boolean forceClear); ConnectionOptions forceClear(); ConnectionOptions forceClear(@DefaultValue(value = "FALSE") boolean forceClear); boolean isSkipCleanup(); void setSkipCleanup(@DefaultValue(value = "FALSE") boolean skipCleanup); ConnectionOptions skipCleanup(@DefaultValue(value = "FALSE") boolean skipCleanup); ConnectionOptions skipCleanup(); @Override ConnectionOptions clone(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static final String ENVIRONMENT_VARIABLE_HOST; static final String ENVIRONMENT_VARIABLE_HTTP_LOG_LEVEL; static final String ENVIRONMENT_VARIABLE_API_KEY; static final String ENVIRONMENT_VARIABLE_NOTIFICATION_CHANNEL_FORCE_CLEAR; static final String ENVIRONMENT_VARIABLE_NOTIFICATION_CHANNEL_SKIP_CLEANUP; static final String ENVIRONMENT_VARIABLE_NOTIFICATION_CHANNEL_AUTOSTART; }### Answer: @Test public void testHost() { ConnectionOptions opt = ConnectionOptions.newConfiguration(); assertFalse(opt.isHostEmpty()); opt.host(null); assertFalse(opt.isHostEmpty()); opt.host(""); assertFalse(opt.isHostEmpty()); opt.host("\'\'"); assertFalse(opt.isHostEmpty()); opt.host("''"); assertFalse(opt.isHostEmpty()); opt.host("' \t '"); assertFalse(opt.isHostEmpty()); opt.host("\"\""); assertFalse(opt.isHostEmpty()); assertTrue(opt.getHost().endsWith("/")); }
### Question: LightThemeColor extends AbstractLightThemeColor { @Override public boolean isValid() { return super.isValid() && reference != null; } @Internal LightThemeColor(String color, LightThemeColorReference reference, Date updatedAt); @Internal LightThemeColor(LightThemeColor lightThemeColor); LightThemeColor(); @Internal LightThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setLightThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override LightThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { LightThemeColor lightthemecolor = new LightThemeColor("00a251ea-b724-46e0-93d6-6ff55bfc7a5f", LightThemeColorReference.getDefault(), new Date(1559758609121L)); assertTrue(lightthemecolor.isValid()); LightThemeColor lightthemecolorInvalid = new LightThemeColor("e6695cf6-a493-4812-b2df-f628fb990f10", null, new Date(1559758610143L)); assertFalse(lightthemecolorInvalid.isValid()); }
### Question: LightThemeColor extends AbstractLightThemeColor { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!super.equals(obj)) { return false; } if (!(obj instanceof LightThemeColor)) { return false; } final LightThemeColor other = (LightThemeColor) obj; if (!other.canEqual(this)) { return false; } return true; } @Internal LightThemeColor(String color, LightThemeColorReference reference, Date updatedAt); @Internal LightThemeColor(LightThemeColor lightThemeColor); LightThemeColor(); @Internal LightThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setLightThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override LightThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { LightThemeColor lightthemecolor1 = new LightThemeColor("4788c0c2-7fb8-4bcd-809e-9015a9f505ab", LightThemeColorReference.getDefault(), new Date(1559758607555L)); LightThemeColor lightthemecolor2 = new LightThemeColor("4788c0c2-7fb8-4bcd-809e-9015a9f505ab", LightThemeColorReference.getDefault(), new Date(1559758607555L)); LightThemeColor lightthemecolor3 = new LightThemeColor("19791b60-22b6-4057-a146-1dccae14754e", LightThemeColorReference.getDefault(), new Date(1559758609577L)); assertNotNull(lightthemecolor1); assertNotNull(lightthemecolor2); assertNotNull(lightthemecolor3); assertNotSame(lightthemecolor2, lightthemecolor1); assertNotSame(lightthemecolor3, lightthemecolor1); assertEquals(lightthemecolor2, lightthemecolor1); assertEquals(lightthemecolor2, lightthemecolor1); assertEquals(lightthemecolor1, lightthemecolor2); assertEquals(lightthemecolor1, lightthemecolor1); assertFalse(lightthemecolor1.equals(null)); assertNotEquals(lightthemecolor3, lightthemecolor1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DarkThemeImage extends AbstractDarkThemeImage { @Override public DarkThemeImage clone() { return new DarkThemeImage(this); } @Internal DarkThemeImage(DarkThemeImageReference reference, String staticUri, Date updatedAt); @Internal DarkThemeImage(DarkThemeImage darkThemeImage); DarkThemeImage(); @Internal DarkThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setDarkThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override DarkThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { DarkThemeImage darkthemeimage1 = new DarkThemeImage(DarkThemeImageReference.getDefault(), "928edf90-458c-45d6-b104-f8b36a13b348", new Date(1559758612235L)); DarkThemeImage darkthemeimage2 = darkthemeimage1.clone(); assertNotNull(darkthemeimage1); assertNotNull(darkthemeimage2); assertNotSame(darkthemeimage2, darkthemeimage1); assertEquals(darkthemeimage2, darkthemeimage1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DarkThemeImage extends AbstractDarkThemeImage { @SuppressWarnings("PMD.UselessOverridingMethod") @Override public int hashCode() { return super.hashCode(); } @Internal DarkThemeImage(DarkThemeImageReference reference, String staticUri, Date updatedAt); @Internal DarkThemeImage(DarkThemeImage darkThemeImage); DarkThemeImage(); @Internal DarkThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setDarkThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override DarkThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { DarkThemeImage darkthemeimage1 = new DarkThemeImage(DarkThemeImageReference.getDefault(), "e15c60e3-bbf4-4b45-95dd-e6a38dd3727f", new Date(1559758608044L)); DarkThemeImage darkthemeimage2 = new DarkThemeImage(DarkThemeImageReference.getDefault(), "e15c60e3-bbf4-4b45-95dd-e6a38dd3727f", new Date(1559758608044L)); assertNotNull(darkthemeimage1); assertNotNull(darkthemeimage2); assertNotSame(darkthemeimage2, darkthemeimage1); assertEquals(darkthemeimage2, darkthemeimage1); assertEquals(darkthemeimage2.hashCode(), darkthemeimage1.hashCode()); int hashCode = darkthemeimage1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, darkthemeimage1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DarkThemeImage extends AbstractDarkThemeImage { @Override public boolean isValid() { return super.isValid() && reference != null; } @Internal DarkThemeImage(DarkThemeImageReference reference, String staticUri, Date updatedAt); @Internal DarkThemeImage(DarkThemeImage darkThemeImage); DarkThemeImage(); @Internal DarkThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setDarkThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override DarkThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { DarkThemeImage darkthemeimage = new DarkThemeImage(DarkThemeImageReference.getDefault(), "149020d4-f501-45d3-9d24-6ea56ca61b28", new Date(1559758603984L)); assertTrue(darkthemeimage.isValid()); DarkThemeImage darkthemeimageInvalid = new DarkThemeImage(null, "e9f1565c-284c-4f29-8021-3ed63146b637", new Date(1559758610582L)); assertFalse(darkthemeimageInvalid.isValid()); }
### Question: DarkThemeImage extends AbstractDarkThemeImage { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!super.equals(obj)) { return false; } if (!(obj instanceof DarkThemeImage)) { return false; } final DarkThemeImage other = (DarkThemeImage) obj; if (!other.canEqual(this)) { return false; } return true; } @Internal DarkThemeImage(DarkThemeImageReference reference, String staticUri, Date updatedAt); @Internal DarkThemeImage(DarkThemeImage darkThemeImage); DarkThemeImage(); @Internal DarkThemeImage(String staticUri, Date updatedAt); @Override void setId(String id); @Internal void setDarkThemeImageId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override DarkThemeImage clone(); }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { DarkThemeImage darkthemeimage1 = new DarkThemeImage(DarkThemeImageReference.getDefault(), "170c2079-87c5-4791-b025-fe24999bf631", new Date(1559758606019L)); DarkThemeImage darkthemeimage2 = new DarkThemeImage(DarkThemeImageReference.getDefault(), "170c2079-87c5-4791-b025-fe24999bf631", new Date(1559758606019L)); DarkThemeImage darkthemeimage3 = new DarkThemeImage(DarkThemeImageReference.getDefault(), "8e42f6d3-656f-40dd-b344-f0f7aa177d24", new Date(1559758609001L)); assertNotNull(darkthemeimage1); assertNotNull(darkthemeimage2); assertNotNull(darkthemeimage3); assertNotSame(darkthemeimage2, darkthemeimage1); assertNotSame(darkthemeimage3, darkthemeimage1); assertEquals(darkthemeimage2, darkthemeimage1); assertEquals(darkthemeimage2, darkthemeimage1); assertEquals(darkthemeimage1, darkthemeimage2); assertEquals(darkthemeimage1, darkthemeimage1); assertFalse(darkthemeimage1.equals(null)); assertNotEquals(darkthemeimage3, darkthemeimage1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: SubtenantDarkThemeColor extends AbstractSubtenantDarkThemeColor { @Override public SubtenantDarkThemeColor clone() { return new SubtenantDarkThemeColor(this); } @Internal SubtenantDarkThemeColor(String color, SubtenantDarkThemeColorReference reference, Date updatedAt); @Internal SubtenantDarkThemeColor(SubtenantDarkThemeColor subtenantDarkThemeColor); SubtenantDarkThemeColor(); @Internal SubtenantDarkThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setSubtenantDarkThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantDarkThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { SubtenantDarkThemeColor subtenantdarkthemecolor1 = new SubtenantDarkThemeColor("4205bf91-0396-404a-8817-862a4e877bae", SubtenantDarkThemeColorReference.getDefault(), new Date(1559758610302L)); SubtenantDarkThemeColor subtenantdarkthemecolor2 = subtenantdarkthemecolor1.clone(); assertNotNull(subtenantdarkthemecolor1); assertNotNull(subtenantdarkthemecolor2); assertNotSame(subtenantdarkthemecolor2, subtenantdarkthemecolor1); assertEquals(subtenantdarkthemecolor2, subtenantdarkthemecolor1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: SubtenantDarkThemeColor extends AbstractSubtenantDarkThemeColor { @SuppressWarnings("PMD.UselessOverridingMethod") @Override public int hashCode() { return super.hashCode(); } @Internal SubtenantDarkThemeColor(String color, SubtenantDarkThemeColorReference reference, Date updatedAt); @Internal SubtenantDarkThemeColor(SubtenantDarkThemeColor subtenantDarkThemeColor); SubtenantDarkThemeColor(); @Internal SubtenantDarkThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setSubtenantDarkThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantDarkThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { SubtenantDarkThemeColor subtenantdarkthemecolor1 = new SubtenantDarkThemeColor("f2a76d7e-06e4-4f24-b0cf-9b0db06cd8d3", SubtenantDarkThemeColorReference.getDefault(), new Date(1559758605434L)); SubtenantDarkThemeColor subtenantdarkthemecolor2 = new SubtenantDarkThemeColor("f2a76d7e-06e4-4f24-b0cf-9b0db06cd8d3", SubtenantDarkThemeColorReference.getDefault(), new Date(1559758605434L)); assertNotNull(subtenantdarkthemecolor1); assertNotNull(subtenantdarkthemecolor2); assertNotSame(subtenantdarkthemecolor2, subtenantdarkthemecolor1); assertEquals(subtenantdarkthemecolor2, subtenantdarkthemecolor1); assertEquals(subtenantdarkthemecolor2.hashCode(), subtenantdarkthemecolor1.hashCode()); int hashCode = subtenantdarkthemecolor1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, subtenantdarkthemecolor1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: SubtenantDarkThemeColor extends AbstractSubtenantDarkThemeColor { @Override public boolean isValid() { return super.isValid() && reference != null; } @Internal SubtenantDarkThemeColor(String color, SubtenantDarkThemeColorReference reference, Date updatedAt); @Internal SubtenantDarkThemeColor(SubtenantDarkThemeColor subtenantDarkThemeColor); SubtenantDarkThemeColor(); @Internal SubtenantDarkThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setSubtenantDarkThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantDarkThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { SubtenantDarkThemeColor subtenantdarkthemecolor = new SubtenantDarkThemeColor("d50e3610-3522-4744-b2ee-2cd8c29c937d", SubtenantDarkThemeColorReference.getDefault(), new Date(1559758606830L)); assertTrue(subtenantdarkthemecolor.isValid()); SubtenantDarkThemeColor subtenantdarkthemecolorInvalid = new SubtenantDarkThemeColor("4d9c0a4e-7935-4270-98dc-0f6c4e0cef0d", null, new Date(1559758605310L)); assertFalse(subtenantdarkthemecolorInvalid.isValid()); }
### Question: SubtenantDarkThemeColor extends AbstractSubtenantDarkThemeColor { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!super.equals(obj)) { return false; } if (!(obj instanceof SubtenantDarkThemeColor)) { return false; } final SubtenantDarkThemeColor other = (SubtenantDarkThemeColor) obj; if (!other.canEqual(this)) { return false; } return true; } @Internal SubtenantDarkThemeColor(String color, SubtenantDarkThemeColorReference reference, Date updatedAt); @Internal SubtenantDarkThemeColor(SubtenantDarkThemeColor subtenantDarkThemeColor); SubtenantDarkThemeColor(); @Internal SubtenantDarkThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setSubtenantDarkThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantDarkThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { SubtenantDarkThemeColor subtenantdarkthemecolor1 = new SubtenantDarkThemeColor("70b3c8dc-abeb-4e19-8b77-ee4562b59e24", SubtenantDarkThemeColorReference.getDefault(), new Date(1559758606542L)); SubtenantDarkThemeColor subtenantdarkthemecolor2 = new SubtenantDarkThemeColor("70b3c8dc-abeb-4e19-8b77-ee4562b59e24", SubtenantDarkThemeColorReference.getDefault(), new Date(1559758606542L)); SubtenantDarkThemeColor subtenantdarkthemecolor3 = new SubtenantDarkThemeColor("8c67105f-83eb-427f-894b-57a0737096f3", SubtenantDarkThemeColorReference.getDefault(), new Date(1559758607136L)); assertNotNull(subtenantdarkthemecolor1); assertNotNull(subtenantdarkthemecolor2); assertNotNull(subtenantdarkthemecolor3); assertNotSame(subtenantdarkthemecolor2, subtenantdarkthemecolor1); assertNotSame(subtenantdarkthemecolor3, subtenantdarkthemecolor1); assertEquals(subtenantdarkthemecolor2, subtenantdarkthemecolor1); assertEquals(subtenantdarkthemecolor2, subtenantdarkthemecolor1); assertEquals(subtenantdarkthemecolor1, subtenantdarkthemecolor2); assertEquals(subtenantdarkthemecolor1, subtenantdarkthemecolor1); assertFalse(subtenantdarkthemecolor1.equals(null)); assertNotEquals(subtenantdarkthemecolor3, subtenantdarkthemecolor1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: ConnectionOptions implements Cloneable, Serializable { protected static boolean isEntryEmpty(String entry) { if (entry == null \|\| entry.isEmpty()) { return true; } return entry.replace("\'", "").replace("\"", "").trim().isEmpty(); } ConnectionOptions(); ConnectionOptions(String apiKey); ConnectionOptions(String apiKey, String host); static ConnectionOptions newConfiguration(); static ConnectionOptions newConfiguration(String apiKey); static ConnectionOptions newConfiguration(String apiKey, String host); String getApiKey(); void setApiKey(String apiKey); boolean isApiKeyEmpty(); boolean isHostEmpty(); boolean isValid(); String getHost(); URL getHostUrl(); void setHost(String host); ConnectionOptions host(String cloudHost); CallLogLevel getClientLogLevel(); void setClientLogLevel(CallLogLevel clientLogLevel); void setClientLogLevel(String clientLogLevel); ConnectionOptions logLevel(CallLogLevel logLevelOfTheHttpClient); TimePeriod getRequestTimeout(); void setRequestTimeout(TimePeriod requestTimeout); boolean hasCustomRequestTimeout(); boolean isAutostartDaemon(); void setAutostartDaemon(@DefaultValue(value = "TRUE") boolean autostartDaemon); ConnectionOptions autostartDaemon(@DefaultValue(value = "TRUE") boolean autostartDaemonMode); ConnectionOptions autostartDaemon(); boolean isForceClear(); void setForceClear(@DefaultValue(value = "FALSE") boolean forceClear); ConnectionOptions forceClear(); ConnectionOptions forceClear(@DefaultValue(value = "FALSE") boolean forceClear); boolean isSkipCleanup(); void setSkipCleanup(@DefaultValue(value = "FALSE") boolean skipCleanup); ConnectionOptions skipCleanup(@DefaultValue(value = "FALSE") boolean skipCleanup); ConnectionOptions skipCleanup(); @Override ConnectionOptions clone(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static final String ENVIRONMENT_VARIABLE_HOST; static final String ENVIRONMENT_VARIABLE_HTTP_LOG_LEVEL; static final String ENVIRONMENT_VARIABLE_API_KEY; static final String ENVIRONMENT_VARIABLE_NOTIFICATION_CHANNEL_FORCE_CLEAR; static final String ENVIRONMENT_VARIABLE_NOTIFICATION_CHANNEL_SKIP_CLEANUP; static final String ENVIRONMENT_VARIABLE_NOTIFICATION_CHANNEL_AUTOSTART; }### Answer: @Test public void testIsEntryEmpty() { assertTrue(ConnectionOptions.isEntryEmpty(null)); assertTrue(ConnectionOptions.isEntryEmpty("\'\'")); assertTrue(ConnectionOptions.isEntryEmpty("\"\"")); assertTrue(ConnectionOptions.isEntryEmpty("\" \"")); assertTrue(ConnectionOptions.isEntryEmpty("''")); assertTrue(ConnectionOptions.isEntryEmpty("' '")); assertTrue(ConnectionOptions.isEntryEmpty("' \t '")); assertFalse(ConnectionOptions.isEntryEmpty("' this is a test '")); }
### Question: SubtenantLightThemeColor extends AbstractSubtenantLightThemeColor { @Override public SubtenantLightThemeColor clone() { return new SubtenantLightThemeColor(this); } @Internal SubtenantLightThemeColor(String color, SubtenantLightThemeColorReference reference, Date updatedAt); @Internal SubtenantLightThemeColor(SubtenantLightThemeColor subtenantLightThemeColor); SubtenantLightThemeColor(); @Internal SubtenantLightThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setSubtenantLightThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantLightThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { SubtenantLightThemeColor subtenantlightthemecolor1 = new SubtenantLightThemeColor("c70d1c85-2eb2-4d5f-b852-10daa189a2eb", SubtenantLightThemeColorReference.getDefault(), new Date(1559758608923L)); SubtenantLightThemeColor subtenantlightthemecolor2 = subtenantlightthemecolor1.clone(); assertNotNull(subtenantlightthemecolor1); assertNotNull(subtenantlightthemecolor2); assertNotSame(subtenantlightthemecolor2, subtenantlightthemecolor1); assertEquals(subtenantlightthemecolor2, subtenantlightthemecolor1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: SubtenantLightThemeColor extends AbstractSubtenantLightThemeColor { @SuppressWarnings("PMD.UselessOverridingMethod") @Override public int hashCode() { return super.hashCode(); } @Internal SubtenantLightThemeColor(String color, SubtenantLightThemeColorReference reference, Date updatedAt); @Internal SubtenantLightThemeColor(SubtenantLightThemeColor subtenantLightThemeColor); SubtenantLightThemeColor(); @Internal SubtenantLightThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setSubtenantLightThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantLightThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { SubtenantLightThemeColor subtenantlightthemecolor1 = new SubtenantLightThemeColor("34116fe2-b396-4368-ba88-b1b4426a7962", SubtenantLightThemeColorReference.getDefault(), new Date(1559758605216L)); SubtenantLightThemeColor subtenantlightthemecolor2 = new SubtenantLightThemeColor("34116fe2-b396-4368-ba88-b1b4426a7962", SubtenantLightThemeColorReference.getDefault(), new Date(1559758605216L)); assertNotNull(subtenantlightthemecolor1); assertNotNull(subtenantlightthemecolor2); assertNotSame(subtenantlightthemecolor2, subtenantlightthemecolor1); assertEquals(subtenantlightthemecolor2, subtenantlightthemecolor1); assertEquals(subtenantlightthemecolor2.hashCode(), subtenantlightthemecolor1.hashCode()); int hashCode = subtenantlightthemecolor1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, subtenantlightthemecolor1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: SubtenantLightThemeColor extends AbstractSubtenantLightThemeColor { @Override public boolean isValid() { return super.isValid() && reference != null; } @Internal SubtenantLightThemeColor(String color, SubtenantLightThemeColorReference reference, Date updatedAt); @Internal SubtenantLightThemeColor(SubtenantLightThemeColor subtenantLightThemeColor); SubtenantLightThemeColor(); @Internal SubtenantLightThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setSubtenantLightThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantLightThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { SubtenantLightThemeColor subtenantlightthemecolor = new SubtenantLightThemeColor("a66ae0a6-687d-4067-8cbc-7d89b07742f0", SubtenantLightThemeColorReference.getDefault(), new Date(1559758610190L)); assertTrue(subtenantlightthemecolor.isValid()); SubtenantLightThemeColor subtenantlightthemecolorInvalid = new SubtenantLightThemeColor("d2ecf8f5-8bfc-4f96-8337-7e29b477ef30", null, new Date(1559758609702L)); assertFalse(subtenantlightthemecolorInvalid.isValid()); }
### Question: SubtenantLightThemeColor extends AbstractSubtenantLightThemeColor { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!super.equals(obj)) { return false; } if (!(obj instanceof SubtenantLightThemeColor)) { return false; } final SubtenantLightThemeColor other = (SubtenantLightThemeColor) obj; if (!other.canEqual(this)) { return false; } return true; } @Internal SubtenantLightThemeColor(String color, SubtenantLightThemeColorReference reference, Date updatedAt); @Internal SubtenantLightThemeColor(SubtenantLightThemeColor subtenantLightThemeColor); SubtenantLightThemeColor(); @Internal SubtenantLightThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setSubtenantLightThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override SubtenantLightThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { SubtenantLightThemeColor subtenantlightthemecolor1 = new SubtenantLightThemeColor("649671a8-48c7-4699-801a-7c4d4809a371", SubtenantLightThemeColorReference.getDefault(), new Date(1559758605567L)); SubtenantLightThemeColor subtenantlightthemecolor2 = new SubtenantLightThemeColor("649671a8-48c7-4699-801a-7c4d4809a371", SubtenantLightThemeColorReference.getDefault(), new Date(1559758605567L)); SubtenantLightThemeColor subtenantlightthemecolor3 = new SubtenantLightThemeColor("e8577296-9d6c-4124-be6f-3a32c2902d9c", SubtenantLightThemeColorReference.getDefault(), new Date(1559758606123L)); assertNotNull(subtenantlightthemecolor1); assertNotNull(subtenantlightthemecolor2); assertNotNull(subtenantlightthemecolor3); assertNotSame(subtenantlightthemecolor2, subtenantlightthemecolor1); assertNotSame(subtenantlightthemecolor3, subtenantlightthemecolor1); assertEquals(subtenantlightthemecolor2, subtenantlightthemecolor1); assertEquals(subtenantlightthemecolor2, subtenantlightthemecolor1); assertEquals(subtenantlightthemecolor1, subtenantlightthemecolor2); assertEquals(subtenantlightthemecolor1, subtenantlightthemecolor1); assertFalse(subtenantlightthemecolor1.equals(null)); assertNotEquals(subtenantlightthemecolor3, subtenantlightthemecolor1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DarkThemeColor extends AbstractDarkThemeColor { @Override public DarkThemeColor clone() { return new DarkThemeColor(this); } @Internal DarkThemeColor(String color, DarkThemeColorReference reference, Date updatedAt); @Internal DarkThemeColor(DarkThemeColor darkThemeColor); DarkThemeColor(); @Internal DarkThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setDarkThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override DarkThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { DarkThemeColor darkthemecolor1 = new DarkThemeColor("773768b2-7a11-4a2e-8ef0-2c5dc8bd5eb4", DarkThemeColorReference.getDefault(), new Date(1559758609723L)); DarkThemeColor darkthemecolor2 = darkthemecolor1.clone(); assertNotNull(darkthemecolor1); assertNotNull(darkthemecolor2); assertNotSame(darkthemecolor2, darkthemecolor1); assertEquals(darkthemecolor2, darkthemecolor1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DarkThemeColor extends AbstractDarkThemeColor { @SuppressWarnings("PMD.UselessOverridingMethod") @Override public int hashCode() { return super.hashCode(); } @Internal DarkThemeColor(String color, DarkThemeColorReference reference, Date updatedAt); @Internal DarkThemeColor(DarkThemeColor darkThemeColor); DarkThemeColor(); @Internal DarkThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setDarkThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override DarkThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { DarkThemeColor darkthemecolor1 = new DarkThemeColor("10d6fe06-930f-4dd8-be7f-5067c1f5f851", DarkThemeColorReference.getDefault(), new Date(1559758606485L)); DarkThemeColor darkthemecolor2 = new DarkThemeColor("10d6fe06-930f-4dd8-be7f-5067c1f5f851", DarkThemeColorReference.getDefault(), new Date(1559758606485L)); assertNotNull(darkthemecolor1); assertNotNull(darkthemecolor2); assertNotSame(darkthemecolor2, darkthemecolor1); assertEquals(darkthemecolor2, darkthemecolor1); assertEquals(darkthemecolor2.hashCode(), darkthemecolor1.hashCode()); int hashCode = darkthemecolor1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, darkthemecolor1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: DarkThemeColor extends AbstractDarkThemeColor { @Override public boolean isValid() { return super.isValid() && reference != null; } @Internal DarkThemeColor(String color, DarkThemeColorReference reference, Date updatedAt); @Internal DarkThemeColor(DarkThemeColor darkThemeColor); DarkThemeColor(); @Internal DarkThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setDarkThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override DarkThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { DarkThemeColor darkthemecolor = new DarkThemeColor("27430878-3909-4261-9331-2745318db920", DarkThemeColorReference.getDefault(), new Date(1559758610533L)); assertTrue(darkthemecolor.isValid()); DarkThemeColor darkthemecolorInvalid = new DarkThemeColor("f3f7b3f8-e629-49e3-a50d-89e05452a0d1", null, new Date(1559758603777L)); assertFalse(darkthemecolorInvalid.isValid()); }
### Question: DarkThemeColor extends AbstractDarkThemeColor { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!super.equals(obj)) { return false; } if (!(obj instanceof DarkThemeColor)) { return false; } final DarkThemeColor other = (DarkThemeColor) obj; if (!other.canEqual(this)) { return false; } return true; } @Internal DarkThemeColor(String color, DarkThemeColorReference reference, Date updatedAt); @Internal DarkThemeColor(DarkThemeColor darkThemeColor); DarkThemeColor(); @Internal DarkThemeColor(Date updatedAt); @Override void setId(String id); @Internal void setDarkThemeColorId(String id); @Override String getId(); @Override String toString(); @Override boolean equals(Object obj); @SuppressWarnings("PMD.UselessOverridingMethod") @Override int hashCode(); @Override boolean isValid(); @Override DarkThemeColor clone(); }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { DarkThemeColor darkthemecolor1 = new DarkThemeColor("95e49618-f5f7-4e73-bd13-e1c4da3b6fa4", DarkThemeColorReference.getDefault(), new Date(1559758604963L)); DarkThemeColor darkthemecolor2 = new DarkThemeColor("95e49618-f5f7-4e73-bd13-e1c4da3b6fa4", DarkThemeColorReference.getDefault(), new Date(1559758604963L)); DarkThemeColor darkthemecolor3 = new DarkThemeColor("14336e30-7c7b-4cdf-bd32-9420a8907f08", DarkThemeColorReference.getDefault(), new Date(1559758607654L)); assertNotNull(darkthemecolor1); assertNotNull(darkthemecolor2); assertNotNull(darkthemecolor3); assertNotSame(darkthemecolor2, darkthemecolor1); assertNotSame(darkthemecolor3, darkthemecolor1); assertEquals(darkthemecolor2, darkthemecolor1); assertEquals(darkthemecolor2, darkthemecolor1); assertEquals(darkthemecolor1, darkthemecolor2); assertEquals(darkthemecolor1, darkthemecolor1); assertFalse(darkthemecolor1.equals(null)); assertNotEquals(darkthemecolor3, darkthemecolor1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: PasswordPolicy implements SdkModel { @Override public PasswordPolicy clone() { return new PasswordPolicy(this); } @Internal PasswordPolicy(@DefaultValue("8") int minimumLength); @Internal PasswordPolicy(PasswordPolicy passwordPolicy); PasswordPolicy(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); int getMinimumLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override PasswordPolicy clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { PasswordPolicy passwordpolicy1 = new PasswordPolicy(8); PasswordPolicy passwordpolicy2 = passwordpolicy1.clone(); assertNotNull(passwordpolicy1); assertNotNull(passwordpolicy2); assertNotSame(passwordpolicy2, passwordpolicy1); assertEquals(passwordpolicy2, passwordpolicy1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: PasswordPolicy implements SdkModel { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + Objects.hashCode(Integer.valueOf(minimumLength)); return result; } @Internal PasswordPolicy(@DefaultValue("8") int minimumLength); @Internal PasswordPolicy(PasswordPolicy passwordPolicy); PasswordPolicy(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); int getMinimumLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override PasswordPolicy clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { PasswordPolicy passwordpolicy1 = new PasswordPolicy(8); PasswordPolicy passwordpolicy2 = new PasswordPolicy(8); assertNotNull(passwordpolicy1); assertNotNull(passwordpolicy2); assertNotSame(passwordpolicy2, passwordpolicy1); assertEquals(passwordpolicy2, passwordpolicy1); assertEquals(passwordpolicy2.hashCode(), passwordpolicy1.hashCode()); int hashCode = passwordpolicy1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, passwordpolicy1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: PasswordPolicy implements SdkModel { @Override public boolean isValid() { return true; } @Internal PasswordPolicy(@DefaultValue("8") int minimumLength); @Internal PasswordPolicy(PasswordPolicy passwordPolicy); PasswordPolicy(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); int getMinimumLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override PasswordPolicy clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { PasswordPolicy passwordpolicy = new PasswordPolicy(8); assertTrue(passwordpolicy.isValid()); }
### Question: PasswordPolicy implements SdkModel { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!(obj instanceof PasswordPolicy)) { return false; } final PasswordPolicy other = (PasswordPolicy) obj; if (!other.canEqual(this)) { return false; } if (minimumLength != other.minimumLength) { return false; } return true; } @Internal PasswordPolicy(@DefaultValue("8") int minimumLength); @Internal PasswordPolicy(PasswordPolicy passwordPolicy); PasswordPolicy(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); int getMinimumLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override PasswordPolicy clone(); }### Answer: @SuppressWarnings("resource") @Test public void testEquals() { try { PasswordPolicy passwordpolicy1 = new PasswordPolicy(8); PasswordPolicy passwordpolicy2 = new PasswordPolicy(8); assertNotNull(passwordpolicy1); assertNotNull(passwordpolicy2); assertNotSame(passwordpolicy2, passwordpolicy1); assertEquals(passwordpolicy2, passwordpolicy1); assertEquals(passwordpolicy2, passwordpolicy1); assertEquals(passwordpolicy1, passwordpolicy2); assertEquals(passwordpolicy1, passwordpolicy1); assertFalse(passwordpolicy1.equals(null)); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: ActiveSession implements SdkModel { @Override public ActiveSession clone() { return new ActiveSession(this); } @Internal ActiveSession(String accountId, Date createdAt, String ipAddress, Date loginTime, String referenceToken, String userAgent); @Internal ActiveSession(ActiveSession activeSession); ActiveSession(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); String getAccountId(); Date getCreatedAt(); String getIpAddress(); Date getLoginTime(); String getReferenceToken(); String getUserAgent(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override ActiveSession clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { ActiveSession activesession1 = new ActiveSession("4f267f967f7d1f5e3fa0d6abaccdb4bf", new Date(1574704667834L), "836f16bb-c778-47f8-b818-3ef8a09c41c8", new Date(1574704662873L), "19e68c56-1a4e-4869-83a6-a1984412dd33", "4cad5c80-2aca-4e72-987c-5dde4df99774"); ActiveSession activesession2 = activesession1.clone(); assertNotNull(activesession1); assertNotNull(activesession2); assertNotSame(activesession2, activesession1); assertEquals(activesession2, activesession1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: ActiveSession implements SdkModel { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((accountId == null) ? 0 : accountId.hashCode()); result = prime * result + ((createdAt == null) ? 0 : createdAt.hashCode()); result = prime * result + ((ipAddress == null) ? 0 : ipAddress.hashCode()); result = prime * result + ((loginTime == null) ? 0 : loginTime.hashCode()); result = prime * result + ((referenceToken == null) ? 0 : referenceToken.hashCode()); result = prime * result + ((userAgent == null) ? 0 : userAgent.hashCode()); return result; } @Internal ActiveSession(String accountId, Date createdAt, String ipAddress, Date loginTime, String referenceToken, String userAgent); @Internal ActiveSession(ActiveSession activeSession); ActiveSession(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); String getAccountId(); Date getCreatedAt(); String getIpAddress(); Date getLoginTime(); String getReferenceToken(); String getUserAgent(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override ActiveSession clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { ActiveSession activesession1 = new ActiveSession("4f267f967f7d1f5e3fa0d6abaccdb4bf", new Date(1574704666002L), "9bb1a698-7238-4a30-bd12-1e642b32db0a", new Date(1574704669440L), "8068ce1c-ed01-4489-8224-7c5f46dcd384", "9462f14e-1963-4303-8a94-82bd251ba80d"); ActiveSession activesession2 = new ActiveSession("4f267f967f7d1f5e3fa0d6abaccdb4bf", new Date(1574704666002L), "9bb1a698-7238-4a30-bd12-1e642b32db0a", new Date(1574704669440L), "8068ce1c-ed01-4489-8224-7c5f46dcd384", "9462f14e-1963-4303-8a94-82bd251ba80d"); assertNotNull(activesession1); assertNotNull(activesession2); assertNotSame(activesession2, activesession1); assertEquals(activesession2, activesession1); assertEquals(activesession2.hashCode(), activesession1.hashCode()); int hashCode = activesession1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, activesession1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: ActiveSession implements SdkModel { @Override public boolean isValid() { return true; } @Internal ActiveSession(String accountId, Date createdAt, String ipAddress, Date loginTime, String referenceToken, String userAgent); @Internal ActiveSession(ActiveSession activeSession); ActiveSession(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); String getAccountId(); Date getCreatedAt(); String getIpAddress(); Date getLoginTime(); String getReferenceToken(); String getUserAgent(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override ActiveSession clone(); }### Answer: @SuppressWarnings("resource") @Test public void testIsValid() { ActiveSession activesession = new ActiveSession("4f267f967f7d1f5e3fa0d6abaccdb4bf", new Date(1574704663318L), "ddf8d6e7-304b-4bc9-8f35-541090e9bb4a", new Date(1574704663001L), "eb11f938-0339-4ecb-826e-18218963162d", "ee01993f-bd72-4ca8-8535-4bfaaface96a"); assertTrue(activesession.isValid()); }
### Question: Policy implements SdkModel { @Override public Policy clone() { return new Policy(this); } @Internal Policy(String action, boolean allow, String feature, boolean inherited, String inheritedFrom, PolicyInheritedType inheritedType, String resource); @Internal Policy(Policy policy); Policy(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); String getAction(); boolean isAllow(); String getFeature(); boolean isInherited(); String getInheritedFrom(); PolicyInheritedType getInheritedType(); String getResource(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override Policy clone(); }### Answer: @SuppressWarnings("resource") @Test public void testClone() { try { Policy policy1 = new Policy("4f508d38-0f77-4936-806e-bdb2fbcefdaf", true, "46dbd363-f32f-4d98-a6cf-20d460d503ec", true, "4f267f967f7d1f5e3fa0d6abaccdb4bf", PolicyInheritedType.getDefault(), "aa579c93-347c-4d9a-9e8c-1635fb628a4e"); Policy policy2 = policy1.clone(); assertNotNull(policy1); assertNotNull(policy2); assertNotSame(policy2, policy1); assertEquals(policy2, policy1); } catch (Exception exception) { fail(exception.getMessage()); } }
### Question: Policy implements SdkModel { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((action == null) ? 0 : action.hashCode()); result = prime * result + Objects.hashCode(Boolean.valueOf(allow)); result = prime * result + ((feature == null) ? 0 : feature.hashCode()); result = prime * result + Objects.hashCode(Boolean.valueOf(inherited)); result = prime * result + ((inheritedFrom == null) ? 0 : inheritedFrom.hashCode()); result = prime * result + ((inheritedType == null) ? 0 : inheritedType.hashCode()); result = prime * result + ((resource == null) ? 0 : resource.hashCode()); return result; } @Internal Policy(String action, boolean allow, String feature, boolean inherited, String inheritedFrom, PolicyInheritedType inheritedType, String resource); @Internal Policy(Policy policy); Policy(); @Override @Internal @PerformsNoOperation void setId(String id); @Override @Internal String getId(); String getAction(); boolean isAllow(); String getFeature(); boolean isInherited(); String getInheritedFrom(); PolicyInheritedType getInheritedType(); String getResource(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override boolean isValid(); @Override Policy clone(); }### Answer: @SuppressWarnings("resource") @Test public void testHashCode() { try { Policy policy1 = new Policy("e077c872-b7fa-44fd-80d0-fb9c6951ba6b", false, "3240dee3-0bcd-495c-8c8d-14177613fb61", false, "4f267f967f7d1f5e3fa0d6abaccdb4bf", PolicyInheritedType.getDefault(), "9211d0eb-ecd5-4653-88a8-7ef56bb9031a"); Policy policy2 = new Policy("e077c872-b7fa-44fd-80d0-fb9c6951ba6b", false, "3240dee3-0bcd-495c-8c8d-14177613fb61", false, "4f267f967f7d1f5e3fa0d6abaccdb4bf", PolicyInheritedType.getDefault(), "9211d0eb-ecd5-4653-88a8-7ef56bb9031a"); assertNotNull(policy1); assertNotNull(policy2); assertNotSame(policy2, policy1); assertEquals(policy2, policy1); assertEquals(policy2.hashCode(), policy1.hashCode()); int hashCode = policy1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, policy1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.